brackets-prisma-db 1.0.1 → 2.0.0

package/README.md

@@ -31,9 +31,12 @@ 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);
-```
+```

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/select-handlers/group.js

@@ -6,7 +6,9 @@ async function handleGroupSelect(prisma, filter) {
     if (filter === undefined) {
         // Query all entries of table
         return prisma.group
-            .findMany()
+            .findMany({
+            orderBy: [{ number: 'asc' }],
+        })
             .then((values) => values.map(transformers_1.GroupTransformer.from))
             .catch(() => []);
     }
@@ -31,6 +33,7 @@ async function handleGroupSelect(prisma, filter) {
             stageId: filter.stage_id,
             number: filter.number,
         },
+        orderBy: [{ number: 'asc' }],
     })
         .then((values) => values.map(transformers_1.GroupTransformer.from))
         .catch(() => []);

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

@@ -11,6 +11,7 @@ async function handleMatchGameSelect(prisma, filter) {
                 opponent1Result: true,
                 opponent2Result: true,
             },
+            orderBy: [{ number: 'asc' }],
         })
             .then((values) => values.map(transformers_1.MatchGameTransformer.from))
             .catch(() => []);
@@ -48,6 +49,7 @@ async function handleMatchGameSelect(prisma, filter) {
             opponent1Result: true,
             opponent2Result: true,
         },
+        orderBy: [{ number: 'asc' }],
     })
         .then((values) => values.map(transformers_1.MatchGameTransformer.from))
         .catch(() => []);

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

@@ -11,6 +11,14 @@ async function handleMatchSelect(prisma, filter) {
                 opponent1Result: true,
                 opponent2Result: true,
             },
+            orderBy: [
+                {
+                    round: {
+                        number: 'asc',
+                    },
+                },
+                { number: 'asc' },
+            ],
         })
             .then((values) => values.map(transformers_1.MatchTransformer.from))
             .catch(() => []);
@@ -50,6 +58,14 @@ async function handleMatchSelect(prisma, filter) {
             opponent1Result: true,
             opponent2Result: true,
         },
+        orderBy: [
+            {
+                round: {
+                    number: 'asc',
+                },
+            },
+            { number: 'asc' },
+        ],
     })
         .then((values) => values.map(transformers_1.MatchTransformer.from))
         .catch(() => []);

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

@@ -6,7 +6,9 @@ async function handleRoundSelect(prisma, filter) {
     if (filter === undefined) {
         // Query all entries of table
         return prisma.round
-            .findMany()
+            .findMany({
+            orderBy: [{ number: 'asc' }],
+        })
             .then((values) => values.map(transformers_1.RoundTransformer.from))
             .catch(() => []);
     }
@@ -32,6 +34,7 @@ async function handleRoundSelect(prisma, filter) {
             groupId: filter.group_id,
             number: filter.number,
         },
+        orderBy: [{ number: 'asc' }],
     })
         .then((values) => values.map(transformers_1.RoundTransformer.from))
         .catch(() => []);

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

@@ -10,6 +10,7 @@ async function handleStageSelect(prisma, filter) {
             include: {
                 settings: true,
             },
+            orderBy: [{ number: 'asc' }],
         })
             .then((values) => values.map((value) => {
             if (value.settings === null) {
@@ -53,6 +54,7 @@ async function handleStageSelect(prisma, filter) {
         include: {
             settings: true,
         },
+        orderBy: [{ number: 'asc' }],
     })
         .then((values) => values.map((value) => {
         if (value.settings === null) {

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

@@ -8,13 +8,13 @@ export declare const MatchGameTransformer: {
         matchId: number;
         number: number;
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
+    from(output: {
+        number: number;
         id: number;
-        status: Prisma.MatchStatus;
+        status: Prisma.$Enums.MatchStatus;
         stageId: number;
         matchId: number;
-        number: number;
-    }, unknown> & {} & {
+    } & {
         opponent1Result: Prisma.ParticipantMatchGameResult | null;
         opponent2Result: Prisma.ParticipantMatchGameResult | null;
     }): {

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

@@ -10,15 +10,15 @@ export declare const MatchTransformer: {
         number: number;
         childCount: number;
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
+    from(output: {
+        number: number;
         id: number;
-        status: Prisma.MatchStatus;
+        status: Prisma.$Enums.MatchStatus;
         stageId: number;
         groupId: number;
         roundId: number;
-        number: number;
         childCount: number;
-    }, unknown> & {} & {
+    } & {
         opponent1Result: Prisma.ParticipantMatchResult | null;
         opponent2Result: Prisma.ParticipantMatchResult | 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

@@ -5,11 +5,11 @@ export declare const ParticipantTransformer: {
         name: string;
         tournamentId: number;
     };
-    from(output: import("@prisma/client/runtime").GetResult<{
+    from(output: {
         id: number;
-        tournamentId: number;
         name: string;
-    }, unknown> & {}): {
+        tournamentId: number;
+    }): {
         id: number;
         name: string;
         tournament_id: number;

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/package.json

@@ -1,7 +1,7 @@
 {
     "name": "brackets-prisma-db",
-    "version": "1.0.1",
-    "description": "A sql database with prisma for brackets-manager.js",
+    "version": "2.0.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"
     }
 }