brackets-prisma-db 1.0.2 → 2.1.0

package/README.md

@@ -10,10 +10,10 @@ uses [prisma](https://www.prisma.io/) to store the data in an SQL Database.
 
 Currently there are some features of the [manager](https://github.com/Drarig29/brackets-manager.js) that can't be used.
 
-| **Feature**         | **Status**      |
-| ------------------- | --------------- |
-| Custom Participants | Implemented     |
-| Custom Matches      | Not Implemented |
+| **Feature**         | **Status**  |
+| ------------------- | ----------- |
+| Custom Participants | Implemented |
+| Custom Matches      | Implemented |
 
 ## Usage
 
@@ -31,9 +31,55 @@ Lastly push the definition to your database using `npx prisma db push`.
 
 ```typescript
 import { SqlDatabase } from 'brackets-prisma-db';
-import { prisma } from './client';
 import { BracketsManager } from 'brackets-manager';
+import { PrismaClient } from '@prisma/client'
+
+// Your Prisma client
+const prisma = new PrismaClient();
 
 const storage = new SqlDatabase(prisma);
 const manager = new BracketsManager(storage);
-```
+```
+
+Example with custom matches and participants:
+
+```typescript
+import { SqlDatabase } from 'brackets-prisma-db'
+import { PrismaClient } from '@prisma/client'
+import { BracketsManager } from 'brackets-manager'
+import type { Match } from 'brackets-model'
+
+type MatchWithWeather = Match & {
+  extra: {
+    weather: 'sunny' | 'rainy' | 'cloudy' | 'snowy'
+  }
+}
+
+const storage = new SqlDatabase(new PrismaClient())
+const manager = new BracketsManager(storage)
+
+const stage = await manager.create.stage({
+  tournamentId: 1,
+  name: 'Example',
+  type: 'single_elimination',
+  seeding: [
+    { name: 'Team 1', color: 'red' },
+    { name: 'Team 2', color: 'blue' },
+    { name: 'Team 3', color: 'green' },
+    { name: 'Team 4', color: 'yellow' },
+  ],
+})
+
+const currentMatches = await manager.get.currentMatches(stage.id)
+
+await manager.update.match<MatchWithWeather>({
+  id: currentMatches[0].id,
+  opponent1: { result: 'win' },
+  extra: {
+    weather: 'sunny',
+  },
+})
+
+const database = await manager.get.tournamentData(1)
+console.log(database)
+```

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

@@ -3,26 +3,45 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleStageDelete = void 0;
 const transformers_1 = require("../../transformers");
 async function handleStageDelete(prisma, filter) {
-    // No filter so delete everything
-    if (!filter) {
-        return prisma.stage
-            .deleteMany({})
-            .then(() => true)
-            .catch(() => false);
-    }
-    return prisma.stage
-        .deleteMany({
-        where: {
-            id: filter.id,
-            name: filter.name,
-            number: filter.number,
-            tournamentId: filter.tournament_id,
-            type: filter.type
-                ? transformers_1.StageTypeTransformer.to(filter.type)
-                : undefined,
-        },
+    return prisma
+        .$transaction(async (tx) => {
+        // Build where clause if a filter is provided
+        const where = filter
+            ? {
+                id: filter.id,
+                name: filter.name,
+                number: filter.number,
+                tournamentId: filter.tournament_id,
+                type: filter.type
+                    ? transformers_1.StageTypeTransformer.to(filter.type)
+                    : undefined,
+            }
+            : undefined;
+        if (!where) {
+            // No filter: delete in the right order to satisfy FK constraints
+            await tx.stageSettings.deleteMany({});
+            await tx.stage.deleteMany({});
+            return true;
+        }
+        // Filtered delete: find matching stages
+        const stages = await tx.stage.findMany({
+            where,
+            select: { id: true },
+        });
+        if (stages.length === 0)
+            return true;
+        // Delete related StageSettings first to satisfy FK constraints
+        await tx.stageSettings.deleteMany({
+            where: { stageId: { in: stages.map((s) => s.id) } },
+        });
+        // Then delete the stages
+        await tx.stage.deleteMany({ where });
+        return true;
     })
         .then(() => true)
-        .catch(() => false);
+        .catch((e) => {
+        console.error(new Error(`Error deleting stages with filter ${JSON.stringify(filter)}`, { cause: e }));
+        return false;
+    });
 }
 exports.handleStageDelete = handleStageDelete;

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

@@ -1,3 +1,4 @@
-import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { OmitId } from 'brackets-manager/dist/types';
 import { PrismaClient } from '@prisma/client';
-export declare function handleMatchGameInsert(prisma: PrismaClient, values: OmitId<DataTypes['match_game']> | OmitId<DataTypes['match_game']>[]): Promise<number> | Promise<boolean>;
+import type { MatchGameWithExtra } from '../../types';
+export declare function handleMatchGameInsert(prisma: PrismaClient, values: OmitId<MatchGameWithExtra> | OmitId<MatchGameWithExtra>[]): Promise<number> | Promise<boolean>;

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

@@ -5,6 +5,7 @@ const transformers_1 = require("../../transformers");
 function getCreationData(value) {
     return {
         ...transformers_1.MatchGameTransformer.to(value),
+        extra: value.extra ?? undefined,
         opponent1Result: value.opponent1
             ? {
                 create: {

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

@@ -1,3 +1,4 @@
-import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { OmitId } from 'brackets-manager/dist/types';
 import { PrismaClient } from '@prisma/client';
-export declare function handleMatchInsert(prisma: PrismaClient, values: OmitId<DataTypes['match']> | OmitId<DataTypes['match']>[]): Promise<number> | Promise<boolean>;
+import type { MatchWithExtra } from '../../types';
+export declare function handleMatchInsert(prisma: PrismaClient, values: OmitId<MatchWithExtra> | OmitId<MatchWithExtra>[]): Promise<number> | Promise<boolean>;

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

@@ -5,6 +5,7 @@ const transformers_1 = require("../../transformers");
 function getCreationData(value) {
     return {
         ...transformers_1.MatchTransformer.to(value),
+        extra: value.extra ?? undefined,
         opponent1Result: value.opponent1
             ? {
                 create: {

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

@@ -6,14 +6,18 @@ function handleParticipantInsert(prisma, values) {
     if (Array.isArray(values)) {
         return prisma.participant
             .createMany({
-            data: values.map(transformers_1.ParticipantTransformer.to),
+            data: values.map(p => {
+                const value = transformers_1.ParticipantTransformer.to(p);
+                return { ...value, extra: value.extra ?? undefined };
+            }),
         })
             .then(() => true)
             .catch(() => false);
     }
+    const value = transformers_1.ParticipantTransformer.to(values);
     return prisma.participant
         .create({
-        data: transformers_1.ParticipantTransformer.to(values),
+        data: { ...value, extra: value.extra ?? undefined },
     })
         .then((v) => v.id)
         .catch(() => -1);

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleGroupSelect = void 0;
+// @ts-ignore
 const transformers_1 = require("../../transformers");
 async function handleGroupSelect(prisma, filter) {
     if (filter === undefined) {

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
 import { PrismaClient } from '@prisma/client';
-export declare function handleMatchGameSelect(prisma: PrismaClient, filter?: Partial<DataTypes['match_game']> | number): Promise<DataTypes['match_game'][] | DataTypes['match_game'] | null>;
+import type { MatchGameWithExtra } from '../../types';
+export declare function handleMatchGameSelect(prisma: PrismaClient, filter?: Partial<MatchGameWithExtra> | number): Promise<MatchGameWithExtra[] | MatchGameWithExtra | null>;

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

@@ -4,7 +4,6 @@ exports.handleMatchGameSelect = void 0;
 const transformers_1 = require("../../transformers");
 async function handleMatchGameSelect(prisma, filter) {
     if (filter === undefined) {
-        // Query all entries of table
         return prisma.matchGame
             .findMany({
             include: {
@@ -17,7 +16,6 @@ async function handleMatchGameSelect(prisma, filter) {
             .catch(() => []);
     }
     if (typeof filter === 'number') {
-        // Find by Id
         return prisma.matchGame
             .findFirst({
             where: { id: filter },

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
 import { PrismaClient } from '@prisma/client';
-export declare function handleMatchSelect(prisma: PrismaClient, filter?: Partial<DataTypes['match']> | number): Promise<DataTypes['match'][] | DataTypes['match'] | null>;
+import type { MatchWithExtra } from '../../types';
+export declare function handleMatchSelect(prisma: PrismaClient, filter?: Partial<MatchWithExtra> | number): Promise<MatchWithExtra[] | MatchWithExtra | null>;

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

@@ -4,7 +4,6 @@ exports.handleMatchSelect = void 0;
 const transformers_1 = require("../../transformers");
 async function handleMatchSelect(prisma, filter) {
     if (filter === undefined) {
-        // Query all entries of table
         return prisma.match
             .findMany({
             include: {

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
 import { PrismaClient } from '@prisma/client';
-export declare function handleMatchGameUpdate(prisma: PrismaClient, filter: Partial<DataTypes['match_game']> | number, value: Partial<DataTypes['match_game']> | DataTypes['match_game']): Promise<boolean>;
+import type { MatchGameWithExtra } from '../../types';
+export declare function handleMatchGameUpdate(prisma: PrismaClient, filter: Partial<MatchGameWithExtra> | number, value: Partial<MatchGameWithExtra> | MatchGameWithExtra): Promise<boolean>;

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

@@ -26,7 +26,9 @@ function getParticipantResultUpsertData(value) {
         },
     };
 }
-function getUpdateData(value) {
+function getUpdateData(value, previousExtra) {
+    const extrasInput = value;
+    const extra = (0, transformers_1.matchGameExtraFromInput)(extrasInput, previousExtra);
     return {
         stageId: value.stage_id,
         matchId: value.parent_id,
@@ -40,39 +42,53 @@ function getUpdateData(value) {
         opponent2Result: value.opponent2
             ? getParticipantResultUpsertData(value.opponent2)
             : undefined,
+        extra: extra ?? undefined
     };
 }
-function updateById(prisma, id, value) {
+async function updateById(prisma, id, value, previousExtra) {
+    let extraSource = previousExtra ?? null;
+    if (previousExtra === undefined) {
+        const existing = await prisma.matchGame.findUnique({
+            where: { id },
+            select: { extra: true },
+        });
+        extraSource = existing?.extra ?? null;
+    }
     return prisma.matchGame.update({
         where: {
             id,
         },
-        data: getUpdateData(value),
+        data: getUpdateData(value, extraSource),
     });
 }
 async function handleMatchGameUpdate(prisma, filter, value) {
     if (typeof filter === 'number') {
         // Update by Id
-        return updateById(prisma, filter, value)
-            .then(() => true)
-            .catch(() => false);
+        try {
+            await updateById(prisma, filter, value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        const games = await prisma.matchGame.findMany({
+            where: {
+                id: filter.id,
+                number: filter.number,
+                stageId: filter.stage_id,
+                matchId: filter.parent_id,
+                status: filter.status
+                    ? transformers_1.MatchStatusTransformer.to(filter.status)
+                    : undefined,
+            },
+        });
+        await Promise.all(games.map((game) => updateById(prisma, game.id, value, game.extra ?? null)));
+        return true;
+    }
+    catch {
+        return false;
     }
-    return prisma.matchGame
-        .findMany({
-        where: {
-            id: filter.id,
-            number: filter.number,
-            stageId: filter.stage_id,
-            matchId: filter.parent_id,
-            status: filter.status
-                ? transformers_1.MatchStatusTransformer.to(filter.status)
-                : undefined,
-        },
-    })
-        .then((games) => {
-        return Promise.all(games.map((game) => updateById(prisma, game.id, value)));
-    })
-        .then(() => true)
-        .catch(() => false);
 }
 exports.handleMatchGameUpdate = handleMatchGameUpdate;

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
 import { PrismaClient } from '@prisma/client';
-export declare function handleMatchUpdate(prisma: PrismaClient, filter: Partial<DataTypes['match']> | number, value: Partial<DataTypes['match']> | DataTypes['match']): Promise<boolean>;
+import type { MatchWithExtra } from '../../types';
+export declare function handleMatchUpdate(prisma: PrismaClient, filter: Partial<MatchWithExtra> | number, value: Partial<MatchWithExtra> | MatchWithExtra): Promise<boolean>;

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

@@ -26,7 +26,9 @@ function getParticipantResultUpsertData(value) {
         },
     };
 }
-function getUpdateData(value) {
+function getUpdateData(value, previousExtra) {
+    const extrasInput = value;
+    const extra = (0, transformers_1.matchExtraFromInput)(extrasInput, previousExtra);
     return {
         stageId: value.stage_id,
         groupId: value.group_id,
@@ -42,40 +44,54 @@ function getUpdateData(value) {
         opponent2Result: value.opponent2
             ? getParticipantResultUpsertData(value.opponent2)
             : undefined,
+        extra: extra ?? undefined,
     };
 }
-function updateById(prisma, id, value) {
+async function updateById(prisma, id, value, previousExtra) {
+    let extraSource = previousExtra ?? null;
+    if (previousExtra === undefined) {
+        const existing = await prisma.match.findUnique({
+            where: { id },
+            select: { extra: true },
+        });
+        extraSource = existing?.extra ?? null;
+    }
     return prisma.match.update({
         where: {
             id,
         },
-        data: getUpdateData(value),
+        data: getUpdateData(value, extraSource),
     });
 }
 async function handleMatchUpdate(prisma, filter, value) {
     if (typeof filter === 'number') {
         // Update by Id
-        return updateById(prisma, filter, value)
-            .then(() => true)
-            .catch(() => false);
+        try {
+            await updateById(prisma, filter, value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        const matches = await prisma.match.findMany({
+            where: {
+                id: filter.id,
+                number: filter.number,
+                stageId: filter.stage_id,
+                groupId: filter.group_id,
+                roundId: filter.round_id,
+                status: filter.status
+                    ? transformers_1.MatchStatusTransformer.to(filter.status)
+                    : undefined,
+            },
+        });
+        await Promise.all(matches.map((match) => updateById(prisma, match.id, value, match.extra ?? null)));
+        return true;
+    }
+    catch {
+        return false;
     }
-    return prisma.match
-        .findMany({
-        where: {
-            id: filter.id,
-            number: filter.number,
-            stageId: filter.stage_id,
-            groupId: filter.group_id,
-            roundId: filter.round_id,
-            status: filter.status
-                ? transformers_1.MatchStatusTransformer.to(filter.status)
-                : undefined,
-        },
-    })
-        .then((matches) => {
-        return Promise.all(matches.map((match) => updateById(prisma, match.id, value)));
-    })
-        .then(() => true)
-        .catch(() => false);
 }
 exports.handleMatchUpdate = handleMatchUpdate;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleParticipantUpdate = void 0;
+const transformers_1 = require("../../transformers");
 async function handleParticipantUpdate(prisma, filter, value) {
     if (typeof filter === 'number') {
         // Update by Id
@@ -12,6 +13,7 @@ async function handleParticipantUpdate(prisma, filter, value) {
             data: {
                 name: value.name,
                 tournamentId: value.tournament_id,
+                extra: (0, transformers_1.participantExtraFromInput)(value) ?? undefined,
             },
         })
             .then(() => true)
@@ -28,6 +30,7 @@ async function handleParticipantUpdate(prisma, filter, value) {
         data: {
             name: value.name,
             tournamentId: value.tournament_id,
+            extra: (0, transformers_1.participantExtraFromInput)(value) ?? undefined,
         },
     })
         .then(() => true)

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

@@ -2,5 +2,5 @@ import * as Prisma from '@prisma/client';
 import { GrandFinalType } from 'brackets-model';
 export declare const GrandFinalTypeTransformer: {
     to(type: GrandFinalType): "SIMPLE" | "DOUBLE" | "NONE";
-    from(type: Prisma.GrandFinalType): "none" | "simple" | "double";
+    from(type: Prisma.$Enums.GrandFinalType): "none" | "simple" | "double";
 };

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

@@ -2,5 +2,5 @@ import * as Prisma from '@prisma/client';
 import { Result } from 'brackets-model';
 export declare const MatchResultTransformer: {
     to(result: Result): "WIN" | "DRAW" | "LOSS";
-    from(result: Prisma.MatchResult): "win" | "draw" | "loss";
+    from(result: Prisma.$Enums.MatchResult): "win" | "draw" | "loss";
 };

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

@@ -2,5 +2,5 @@ import * as Prisma from '@prisma/client';
 import { Status } from 'brackets-model';
 export declare const MatchStatusTransformer: {
     to(status: Status): "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
-    from(status: Prisma.MatchStatus): Status;
+    from(status: Prisma.$Enums.MatchStatus): Status;
 };

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

@@ -2,5 +2,5 @@ import * as Prisma from '@prisma/client';
 import { RoundRobinMode } from 'brackets-model';
 export declare const RoundRobinModeTransformer: {
     to(mode: RoundRobinMode): "SIMPLE" | "DOUBLE";
-    from(mode: Prisma.RoundRobinMode): "simple" | "double";
+    from(mode: Prisma.$Enums.RoundRobinMode): "simple" | "double";
 };

package/dist/transformers/enum/seed-ordering.d.ts

@@ -2,5 +2,5 @@ import * as Prisma from '@prisma/client';
 import { SeedOrdering } from 'brackets-model';
 export declare const SeedOrderingTransformer: {
     to(ordering: SeedOrdering): "NATURAL" | "REVERSE" | "HALF_SHIFT" | "REVERSE_HALF_SHIFT" | "PAIR_FLIP" | "INNER_OUTER" | "GROUPS_EFFORT_BALANCED" | "GROUPS_SEED_OPTIMIZED" | "GROUPS_BRACKET_OPTIMIZED";
-    from(ordering: Prisma.SeedOrdering): "reverse" | "natural" | "half_shift" | "reverse_half_shift" | "pair_flip" | "inner_outer" | "groups.effort_balanced" | "groups.seed_optimized" | "groups.bracket_optimized";
+    from(ordering: Prisma.$Enums.SeedOrdering): "reverse" | "natural" | "half_shift" | "reverse_half_shift" | "pair_flip" | "inner_outer" | "groups.effort_balanced" | "groups.seed_optimized" | "groups.bracket_optimized";
 };

package/dist/transformers/enum/stage-type.d.ts

@@ -2,5 +2,5 @@ import * as Prisma from '@prisma/client';
 import { StageType } from 'brackets-model';
 export declare const StageTypeTransformer: {
     to(type: StageType): "ROUND_ROBIN" | "SINGLE_ELIMINATION" | "DOUBLE_ELIMINATION";
-    from(type: Prisma.StageType): "round_robin" | "single_elimination" | "double_elimination";
+    from(type: Prisma.$Enums.StageType): "round_robin" | "single_elimination" | "double_elimination";
 };

package/dist/transformers/model/group.d.ts

@@ -5,11 +5,11 @@ export declare const GroupTransformer: {
         stageId: number;
         number: number;
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
+    from(output: {
+        number: number;
         id: number;
         stageId: number;
-        number: number;
-    }, unknown> & {}): {
+    }): {
         id: number;
         stage_id: number;
         number: number;

package/dist/transformers/model/match-game.d.ts

@@ -1,28 +1,22 @@
-import * as Prisma from '@prisma/client';
-import { MatchGame } from 'brackets-model';
+import { Prisma, MatchGame as PrismaMatchGame, ParticipantMatchGameResult as PrismaParticipantMatchGameResult } from '@prisma/client';
 import { OmitId } from 'brackets-manager';
+import type { MatchGameExtrasInput, MatchGameWithExtra } from '../../types';
+type PrismaMatchGameWithRelations = PrismaMatchGame & {
+    opponent1Result: PrismaParticipantMatchGameResult | null;
+    opponent2Result: PrismaParticipantMatchGameResult | null;
+    extra: Prisma.JsonValue | null;
+};
+export declare function matchGameExtraFromInput(input: MatchGameExtrasInput, previousExtra?: Prisma.JsonValue | null): Prisma.JsonValue | null | undefined;
 export declare const MatchGameTransformer: {
-    to(input: Omit<OmitId<MatchGame>, "opponent1" | "opponent2">): {
+    to(input: Omit<OmitId<MatchGameWithExtra>, 'opponent1' | 'opponent2'>): {
+        extra?: Prisma.JsonValue | undefined;
         status: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
         stageId: number;
         matchId: number;
         number: number;
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
-        id: number;
-        status: Prisma.MatchStatus;
-        stageId: number;
-        matchId: number;
-        number: number;
-    }, unknown> & {} & {
-        opponent1Result: Prisma.ParticipantMatchGameResult | null;
-        opponent2Result: Prisma.ParticipantMatchGameResult | null;
-    }): {
-        id: number;
-        status: import("brackets-model").Status;
-        stage_id: number;
-        parent_id: number;
-        number: number;
+    from(output: PrismaMatchGameWithRelations): {
+        extra: string | number | boolean | Prisma.JsonObject | Prisma.JsonArray | undefined;
         opponent1: {
             id: number | null;
             forfeit: boolean | undefined;
@@ -37,5 +31,11 @@ export declare const MatchGameTransformer: {
             score: number | undefined;
             result: "win" | "draw" | "loss" | undefined;
         } | null;
+        id: number;
+        status: import("brackets-model").Status;
+        stage_id: number;
+        parent_id: number;
+        number: number;
     };
 };
+export {};

package/dist/transformers/model/match-game.js

@@ -1,23 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatchGameTransformer = void 0;
+exports.MatchGameTransformer = exports.matchGameExtraFromInput = void 0;
 const __1 = require("..");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getMatchGameExtras(input) {
+    const clone = { ...input };
+    delete clone.id;
+    delete clone.status;
+    delete clone.stage_id;
+    delete clone.parent_id;
+    delete clone.number;
+    delete clone.opponent1;
+    delete clone.opponent2;
+    delete clone.extra;
+    return Object.entries(clone).reduce((extras, [key, value]) => {
+        if (value !== undefined) {
+            extras[key] = value;
+        }
+        return extras;
+    }, {});
+}
+function normalizeMatchGameExtras(extra) {
+    if (!isRecord(extra)) {
+        return {};
+    }
+    return extra;
+}
+function hasOwnExtraProperty(input) {
+    return Object.prototype.hasOwnProperty.call(input, 'extra');
+}
+function matchGameExtraFromInput(input, previousExtra) {
+    const customFields = getMatchGameExtras(input);
+    const hasCustomFields = Object.keys(customFields).length > 0;
+    if (hasOwnExtraProperty(input)) {
+        const providedExtra = input.extra;
+        if (providedExtra === undefined) {
+            return hasCustomFields ? customFields : undefined;
+        }
+        if (isRecord(providedExtra)) {
+            const normalized = providedExtra;
+            return hasCustomFields
+                ? { ...normalized, ...customFields }
+                : normalized;
+        }
+        return providedExtra ?? null;
+    }
+    if (!hasCustomFields) {
+        return undefined;
+    }
+    if (isRecord(previousExtra)) {
+        const normalized = previousExtra;
+        return { ...normalized, ...customFields };
+    }
+    return customFields;
+}
+exports.matchGameExtraFromInput = matchGameExtraFromInput;
 exports.MatchGameTransformer = {
     to(input) {
+        const extrasInput = input;
+        const extra = matchGameExtraFromInput(extrasInput);
         return {
             status: __1.MatchStatusTransformer.to(input.status),
             stageId: input.stage_id,
             matchId: input.parent_id,
             number: input.number,
+            ...(extra !== undefined ? { extra } : {}),
         };
     },
     from(output) {
+        const normalizedExtras = normalizeMatchGameExtras(output.extra);
         return {
             id: output.id,
             status: __1.MatchStatusTransformer.from(output.status),
             stage_id: output.stageId,
             parent_id: output.matchId,
             number: output.number,
+            ...normalizedExtras,
+            extra: output.extra ?? undefined,
             opponent1: output.opponent1Result
                 ? __1.ParticipantMatchResultTransformer.from(output.opponent1Result)
                 : null,

package/dist/transformers/model/match.d.ts

@@ -1,34 +1,24 @@
-import * as Prisma from '@prisma/client';
-import { Match } from 'brackets-model';
+import type { Match as PrismaMatch, ParticipantMatchResult as PrismaParticipantMatchResult, Prisma } from '@prisma/client';
 import { OmitId } from 'brackets-manager';
+import type { MatchExtrasInput, MatchWithExtra } from '../../types';
+type PrismaMatchWithRelations = PrismaMatch & {
+    opponent1Result: PrismaParticipantMatchResult | null;
+    opponent2Result: PrismaParticipantMatchResult | null;
+    extra: Prisma.JsonValue | null;
+};
+export declare function matchExtraFromInput(input: MatchExtrasInput, previousExtra?: Prisma.JsonValue | null): Prisma.JsonValue | null | undefined;
 export declare const MatchTransformer: {
-    to(input: Omit<OmitId<Match>, "opponent1" | "opponent2">): {
+    to(input: Omit<OmitId<MatchWithExtra>, 'opponent1' | 'opponent2'>): {
         status: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
         stageId: number;
         groupId: number;
         roundId: number;
         number: number;
         childCount: number;
+        extra: string | number | boolean | Prisma.JsonObject | Prisma.JsonArray | null;
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
-        id: number;
-        status: Prisma.MatchStatus;
-        stageId: number;
-        groupId: number;
-        roundId: number;
-        number: number;
-        childCount: number;
-    }, unknown> & {} & {
-        opponent1Result: Prisma.ParticipantMatchResult | null;
-        opponent2Result: Prisma.ParticipantMatchResult | null;
-    }): {
-        id: number;
-        status: import("brackets-model").Status;
-        stage_id: number;
-        group_id: number;
-        round_id: number;
-        number: number;
-        child_count: number;
+    from(output: PrismaMatchWithRelations): {
+        extra: string | number | boolean | Prisma.JsonObject | Prisma.JsonArray | undefined;
         opponent1: {
             id: number | null;
             forfeit: boolean | undefined;
@@ -43,5 +33,13 @@ export declare const MatchTransformer: {
             score: number | undefined;
             result: "win" | "draw" | "loss" | undefined;
         } | null;
+        id: number;
+        status: import("brackets-model").Status;
+        stage_id: number;
+        group_id: number;
+        round_id: number;
+        number: number;
+        child_count: number;
     };
 };
+export {};

package/dist/transformers/model/match.js

@@ -1,9 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MatchTransformer = void 0;
+exports.MatchTransformer = exports.matchExtraFromInput = void 0;
 const __1 = require("..");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getMatchExtras(input) {
+    const clone = { ...input };
+    delete clone.id;
+    delete clone.status;
+    delete clone.stage_id;
+    delete clone.group_id;
+    delete clone.round_id;
+    delete clone.number;
+    delete clone.child_count;
+    delete clone.opponent1;
+    delete clone.opponent2;
+    delete clone.extra;
+    return Object.entries(clone).reduce((extras, [key, value]) => {
+        if (value !== undefined) {
+            extras[key] = value;
+        }
+        return extras;
+    }, {});
+}
+function normalizeMatchExtras(extra) {
+    if (!isRecord(extra)) {
+        return {};
+    }
+    return extra;
+}
+function hasOwnExtraProperty(input) {
+    return Object.prototype.hasOwnProperty.call(input, 'extra');
+}
+function matchExtraFromInput(input, previousExtra) {
+    const customFields = getMatchExtras(input);
+    const hasCustomFields = Object.keys(customFields).length > 0;
+    if (hasOwnExtraProperty(input)) {
+        const providedExtra = input.extra;
+        if (providedExtra === undefined) {
+            return hasCustomFields ? customFields : undefined;
+        }
+        if (isRecord(providedExtra)) {
+            const normalized = providedExtra;
+            return hasCustomFields
+                ? { ...normalized, ...customFields }
+                : normalized;
+        }
+        return providedExtra ?? null;
+    }
+    if (!hasCustomFields) {
+        return undefined;
+    }
+    if (isRecord(previousExtra)) {
+        const normalized = previousExtra;
+        return { ...normalized, ...customFields };
+    }
+    return customFields;
+}
+exports.matchExtraFromInput = matchExtraFromInput;
 exports.MatchTransformer = {
     to(input) {
+        const extrasInput = input;
+        const extra = matchExtraFromInput(extrasInput);
         return {
             status: __1.MatchStatusTransformer.to(input.status),
             stageId: input.stage_id,
@@ -11,9 +70,11 @@ exports.MatchTransformer = {
             roundId: input.round_id,
             number: input.number,
             childCount: input.child_count,
+            extra: extra ?? null,
         };
     },
     from(output) {
+        const normalizedExtras = normalizeMatchExtras(output.extra);
         return {
             id: output.id,
             status: __1.MatchStatusTransformer.from(output.status),
@@ -22,6 +83,8 @@ exports.MatchTransformer = {
             round_id: output.roundId,
             number: output.number,
             child_count: output.childCount,
+            ...normalizedExtras,
+            extra: output.extra ?? undefined,
             opponent1: output.opponent1Result
                 ? __1.ParticipantMatchResultTransformer.from(output.opponent1Result)
                 : null,

package/dist/transformers/model/participant-result.d.ts

@@ -8,25 +8,25 @@ export declare const ParticipantMatchResultTransformer: {
         score: number | null;
         result: "WIN" | "DRAW" | "LOSS" | null;
     };
-    from(output: (import("@prisma/client/runtime").GetResult<{
+    from(output: {
         id: number;
-        participantId: number | null;
         position: number | null;
+        result: Prisma.$Enums.MatchResult | null;
+        participantId: number | null;
         forfeit: boolean | null;
         score: number | null;
-        result: Prisma.MatchResult | null;
         opponent1MatchId: number | null;
         opponent2MatchId: number | null;
-    }, unknown> & {}) | (import("@prisma/client/runtime").GetResult<{
+    } | {
         id: number;
-        participantId: number | null;
         position: number | null;
+        result: Prisma.$Enums.MatchResult | null;
+        participantId: number | null;
         forfeit: boolean | null;
         score: number | null;
-        result: Prisma.MatchResult | null;
         opponent1MatchGameId: number | null;
         opponent2MatchGameId: number | null;
-    }, unknown> & {})): {
+    }): {
         id: number | null;
         forfeit: boolean | undefined;
         position: number | undefined;

package/dist/transformers/model/participant.d.ts

@@ -1,15 +1,19 @@
+import { Prisma } from '@prisma/client';
 import { Participant } from 'brackets-model';
 import { OmitId } from 'brackets-manager';
+export declare function participantExtraFromInput(input: Partial<Participant> & Record<string, unknown>): Prisma.JsonValue | null;
 export declare const ParticipantTransformer: {
     to(input: OmitId<Participant>): {
         name: string;
         tournamentId: number;
+        extra: Prisma.JsonValue;
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
+    from(output: {
         id: number;
-        tournamentId: number;
         name: string;
-    }, unknown> & {}): {
+        tournamentId: number;
+        extra: Prisma.JsonValue;
+    }): {
         id: number;
         name: string;
         tournament_id: number;

package/dist/transformers/model/participant.js

@@ -1,21 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParticipantTransformer = void 0;
+exports.ParticipantTransformer = exports.participantExtraFromInput = void 0;
 function getParticipantExtras(input) {
     const clone = { ...input };
     // Delete Participant fields
     delete clone.id;
     delete clone.name;
     delete clone.tournament_id;
+    delete clone.extra;
     // Return Extras
     return clone;
 }
+function getParticipantExtraValue(input) {
+    const extra = getParticipantExtras(input);
+    return Object.keys(extra).length > 0 ? extra : null;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeParticipantExtras(extra) {
+    if (!isRecord(extra)) {
+        return {};
+    }
+    return extra;
+}
+function participantExtraFromInput(input) {
+    return getParticipantExtraValue(input);
+}
+exports.participantExtraFromInput = participantExtraFromInput;
 exports.ParticipantTransformer = {
     to(input) {
         return {
             name: input.name,
             tournamentId: input.tournament_id,
-            ...getParticipantExtras(input),
+            extra: getParticipantExtraValue(input),
         };
     },
     from(output) {
@@ -23,6 +41,7 @@ exports.ParticipantTransformer = {
             id: output.id,
             name: output.name,
             tournament_id: output.tournamentId,
+            ...normalizeParticipantExtras(output.extra),
         };
     },
 };

package/dist/transformers/model/round.d.ts

@@ -6,12 +6,12 @@ export declare const RoundTransformer: {
         groupId: number;
         number: number;
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
+    from(output: {
+        number: number;
         id: number;
         stageId: number;
         groupId: number;
-        number: number;
-    }, unknown> & {}): {
+    }): {
         id: number;
         stage_id: number;
         group_id: number;

package/dist/transformers/model/stage-settings.d.ts

@@ -14,20 +14,20 @@ export declare const StageSettingsTransformer: {
         skipFirstRound: boolean | null;
         grandFinal: "SIMPLE" | "DOUBLE" | "NONE" | null;
     };
-    from(output: Omit<import("@prisma/client/runtime").GetResult<{
+    from(output: Omit<{
         id: string;
-        stageId: number;
         size: number | null;
-        seedOrdering: Prisma.SeedOrdering[];
+        stageId: number;
+        seedOrdering: Prisma.$Enums.SeedOrdering[];
         balanceByes: boolean | null;
         matchesChildCount: number | null;
         groupCount: number | null;
-        roundRobinMode: Prisma.RoundRobinMode | null;
-        manualOrdering: Prisma.Prisma.JsonValue;
+        roundRobinMode: Prisma.$Enums.RoundRobinMode | null;
+        manualOrdering: import("@prisma/client/runtime/library").JsonValue;
         consolationFinal: boolean | null;
         skipFirstRound: boolean | null;
-        grandFinal: Prisma.GrandFinalType | null;
-    }, unknown> & {}, "stageId">): {
+        grandFinal: Prisma.$Enums.GrandFinalType | null;
+    }, "stageId">): {
         id: string;
         size: number | undefined;
         seedOrdering: ("reverse" | "natural" | "half_shift" | "reverse_half_shift" | "pair_flip" | "inner_outer" | "groups.effort_balanced" | "groups.seed_optimized" | "groups.bracket_optimized")[];

package/dist/transformers/model/stage.d.ts

@@ -8,13 +8,13 @@ export declare const StageTransformer: {
         number: number;
         type: "ROUND_ROBIN" | "SINGLE_ELIMINATION" | "DOUBLE_ELIMINATION";
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
+    from(output: {
+        number: number;
+        type: Prisma.$Enums.StageType;
         id: number;
-        tournamentId: number;
         name: string;
-        type: Prisma.StageType;
-        number: number;
-    }, unknown> & {} & {
+        tournamentId: number;
+    } & {
         settings: Prisma.StageSettings;
     }): {
         id: number;

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import { Prisma } from '@prisma/client';
+export type MatchWithExtra = DataTypes['match'] & {
+    extra?: Prisma.JsonValue | null;
+};
+export type MatchExtrasInput = Partial<MatchWithExtra> & Record<string, unknown>;
+export type MatchGameWithExtra = DataTypes['match_game'] & {
+    extra?: Prisma.JsonValue | null;
+};
+export type MatchGameExtrasInput = Partial<MatchGameWithExtra> & Record<string, unknown>;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "brackets-prisma-db",
-    "version": "1.0.2",
-    "description": "A sql database with prisma for brackets-manager.js",
+    "version": "2.1.0",
+    "description": "A SQL database with Prisma for brackets-manager.js",
     "author": "Tandashi",
     "license": "ISC",
     "repository": {
@@ -33,16 +33,15 @@
         "prepublishOnly": "npm run build"
     },
     "dependencies": {
-        "@prisma/client": "^4.16.1",
-        "brackets-manager": "^1.5.8",
-        "brackets-model": "^1.4.0",
+        "@prisma/client": "^6.17.1",
+        "brackets-model": "1.4.0",
         "typescript": "^5.1.3"
     },
     "devDependencies": {
         "@types/node": "^20.3.0",
-        "prisma": "^4.16.1"
+        "prisma": "^6.17.1"
     },
     "peerDependencies": {
-        "brackets-manager": "^1.3.9"
+        "brackets-manager": "1.x"
     }
-}
+}