brackets-prisma-db 2.0.0 → 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
 
@@ -40,3 +40,46 @@ 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/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/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: {
-        number: number;
-        id: number;
-        status: Prisma.$Enums.MatchStatus;
-        stageId: number;
-        matchId: number;
-    } & {
-        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: {
-        number: number;
-        id: number;
-        status: Prisma.$Enums.MatchStatus;
-        stageId: number;
-        groupId: number;
-        roundId: number;
-        childCount: number;
-    } & {
-        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.d.ts

@@ -1,14 +1,18 @@
+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: {
         id: number;
         name: string;
         tournamentId: number;
+        extra: Prisma.JsonValue;
     }): {
         id: number;
         name: string;

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/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,6 +1,6 @@
 {
     "name": "brackets-prisma-db",
-    "version": "2.0.0",
+    "version": "2.1.0",
     "description": "A SQL database with Prisma for brackets-manager.js",
     "author": "Tandashi",
     "license": "ISC",