brackets-prisma-db 2.0.0 → 2.1.1

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

@@ -1,23 +1,85 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MatchGameTransformer = void 0;
+exports.matchGameExtraFromInput = matchGameExtraFromInput;
 const __1 = require("..");
+const prisma_id_1 = require("../../prisma-id");
+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.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,
+            stageId: (0, prisma_id_1.toPrismaId)(input.stage_id),
+            matchId: (0, prisma_id_1.toPrismaId)(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 { OmitId } from 'brackets-manager';
+import type { Match as PrismaMatch, ParticipantMatchResult as PrismaParticipantMatchResult, Prisma } from '@prisma/client';
+import { OmitId } from 'brackets-model';
+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">): {
-        status: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
+    to(input: Omit<OmitId<MatchWithExtra>, "opponent1" | "opponent2">): {
+        status: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED" | "GAME_CANCELLED";
         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,19 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MatchTransformer = void 0;
+exports.matchExtraFromInput = matchExtraFromInput;
 const __1 = require("..");
+const prisma_id_1 = require("../../prisma-id");
+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.MatchTransformer = {
     to(input) {
+        const extrasInput = input;
+        const extra = matchExtraFromInput(extrasInput);
         return {
             status: __1.MatchStatusTransformer.to(input.status),
-            stageId: input.stage_id,
-            groupId: input.group_id,
-            roundId: input.round_id,
+            stageId: (0, prisma_id_1.toPrismaId)(input.stage_id),
+            groupId: (0, prisma_id_1.toPrismaId)(input.group_id),
+            roundId: (0, prisma_id_1.toPrismaId)(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 +84,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

@@ -1,6 +1,6 @@
 import * as Prisma from '@prisma/client';
 import { ParticipantResult } from 'brackets-model';
-import { OmitId } from 'brackets-manager';
+import { OmitId } from 'brackets-model';
 export declare const ParticipantMatchResultTransformer: {
     to(input: OmitId<ParticipantResult>): {
         forfeit: boolean | 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';
+import { OmitId } from 'brackets-model';
+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;
+        id: number;
         tournamentId: number;
+        extra: Prisma.JsonValue | null;
     }): {
         id: number;
         name: string;

package/dist/transformers/model/participant.js

@@ -1,21 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParticipantTransformer = void 0;
+exports.participantExtraFromInput = participantExtraFromInput;
+const prisma_id_1 = require("../../prisma-id");
 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.ParticipantTransformer = {
     to(input) {
         return {
             name: input.name,
-            tournamentId: input.tournament_id,
-            ...getParticipantExtras(input),
+            tournamentId: (0, prisma_id_1.toPrismaId)(input.tournament_id),
+            extra: getParticipantExtraValue(input),
         };
     },
     from(output) {
@@ -23,6 +42,7 @@ exports.ParticipantTransformer = {
             id: output.id,
             name: output.name,
             tournament_id: output.tournamentId,
+            ...normalizeParticipantExtras(output.extra),
         };
     },
 };

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

@@ -1,5 +1,5 @@
 import { Round } from 'brackets-model';
-import { OmitId } from 'brackets-manager';
+import { OmitId } from 'brackets-model';
 export declare const RoundTransformer: {
     to(input: OmitId<Round>): {
         stageId: number;

package/dist/transformers/model/round.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RoundTransformer = void 0;
+const prisma_id_1 = require("../../prisma-id");
 exports.RoundTransformer = {
     to(input) {
         return {
-            stageId: input.stage_id,
-            groupId: input.group_id,
+            stageId: (0, prisma_id_1.toPrismaId)(input.stage_id),
+            groupId: (0, prisma_id_1.toPrismaId)(input.group_id),
             number: input.number,
         };
     },

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

@@ -1,6 +1,6 @@
 import * as Prisma from '@prisma/client';
 import { StageSettings } from 'brackets-model';
-import { OmitId } from 'brackets-manager';
+import { OmitId } from 'brackets-model';
 export declare const StageSettingsTransformer: {
     to(input: OmitId<StageSettings>): {
         size: number | null;
@@ -23,7 +23,7 @@ export declare const StageSettingsTransformer: {
         matchesChildCount: number | null;
         groupCount: number | null;
         roundRobinMode: Prisma.$Enums.RoundRobinMode | null;
-        manualOrdering: import("@prisma/client/runtime/library").JsonValue;
+        manualOrdering: import("@prisma/client/runtime/library").JsonValue | null;
         consolationFinal: boolean | null;
         skipFirstRound: boolean | null;
         grandFinal: Prisma.$Enums.GrandFinalType | null;

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

@@ -1,6 +1,6 @@
 import * as Prisma from '@prisma/client';
 import { Stage } from 'brackets-model';
-import { OmitId } from 'brackets-manager';
+import { OmitId } from 'brackets-model';
 export declare const StageTransformer: {
     to(input: Omit<OmitId<Stage>, "settings">): {
         name: string;
@@ -10,9 +10,9 @@ export declare const StageTransformer: {
     };
     from(output: {
         number: number;
+        name: string;
         type: Prisma.$Enums.StageType;
         id: number;
-        name: string;
         tournamentId: number;
     } & {
         settings: Prisma.StageSettings;

package/dist/transformers/model/stage.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StageTransformer = void 0;
 const __1 = require("..");
+const prisma_id_1 = require("../../prisma-id");
 exports.StageTransformer = {
     to(input) {
         return {
             name: input.name,
-            tournamentId: input.tournament_id,
+            tournamentId: (0, prisma_id_1.toPrismaId)(input.tournament_id),
             number: input.number,
             type: __1.StageTypeTransformer.to(input.type),
         };

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+import { DataTypes } from 'brackets-model';
+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.1",
     "description": "A SQL database with Prisma for brackets-manager.js",
     "author": "Tandashi",
     "license": "ISC",
@@ -29,19 +29,19 @@
     ],
     "scripts": {
         "build": "tsc",
+        "test": "node --test ../test/implementations/prisma.test.js",
         "prepare": "npm run build",
         "prepublishOnly": "npm run build"
     },
+    "peerDependencies": {
+        "brackets-model": "^1.7.0"
+    },
     "dependencies": {
         "@prisma/client": "^6.17.1",
-        "brackets-model": "1.4.0",
         "typescript": "^5.1.3"
     },
     "devDependencies": {
         "@types/node": "^20.3.0",
         "prisma": "^6.17.1"
-    },
-    "peerDependencies": {
-        "brackets-manager": "1.x"
     }
 }