brackets-prisma-db 2.0.0 → 2.1.1

package/README.md

@@ -1,33 +1,23 @@
 # brackets-prisma-db
 
 This implementation of the [`CrudInterface`](https://drarig29.github.io/brackets-docs/reference/manager/interfaces/CrudInterface.html)
-uses [prisma](https://www.prisma.io/) to store the data in an SQL Database.
-
-> **Warning**
-> This implementation has not been full tested yet. Use with caution.
-
-## Limitations
-
-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 |
+uses [Prisma](https://www.prisma.io/) to store the data in a SQL database.
 
 ## Usage
 
-To use this implementation make sure you have [prisma](https://www.prisma.io/) included in your project.
-A Guide on how to include prisma in your project can be found on the official documentation page.
+To use this implementation, make sure you have [Prisma](https://www.prisma.io/) included in your project. You may follow their [Getting Started](https://www.prisma.io/docs/getting-started) guide.
 
-Once [prisma](https://www.prisma.io/) is included in your project copy the [`schema.prisma`](./prisma/schema.prisma) into your project.
+Once [Prisma](https://www.prisma.io/) is included in your project, copy the [`schema.prisma`](./prisma/schema.prisma) into your project.
 If you have an existing `schema.prisma` in your project copy and paste the schema definitions into your existing one.
 
-> **Warning**
+> [!WARNING]  
 > Do not rename any of the models or enums provided! This **will** break the implementation.
 
-Next generate the prisma client using `npx prisma generate`.
-Lastly push the definition to your database using `npx prisma db push`.
+Next, generate the Prisma client using `npx prisma generate`.
+
+And lastly, push the definition to your database using `npx prisma db push`.
+
+### Minimal example
 
 ```typescript
 import { SqlDatabase } from 'brackets-prisma-db';
@@ -40,3 +30,47 @@ 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 & {
+  // The schema defines a JSON column named `extra` in the `Match` and `MatchGame` tables.
+  // Anything you put in the `extra` object will be stored in that column.
+  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: [
+    // Only `name` is mandatory. All other properties are stored in the `Participant` table rows.
+    { 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: { score: 6, result: 'win' },
+  opponent2: { score: 3, result: 'loss' },
+  extra: {
+    weather: 'sunny',
+  },
+})
+```

package/dist/prisma-id.d.ts

@@ -0,0 +1,10 @@
+import type { Id } from 'brackets-model';
+export declare class InvalidPrismaIdError extends Error {
+    constructor(id: Id);
+}
+export declare function isModelId(value: unknown): value is Id;
+export declare function toPrismaId(id: Id): number;
+export declare function toPrismaId(id: null): null;
+export declare function toPrismaId(id: undefined): undefined;
+export declare function toPrismaId(id: Id | null): number | null;
+export declare function toPrismaId(id: Id | undefined): number | undefined;

package/dist/prisma-id.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPrismaIdError = void 0;
+exports.isModelId = isModelId;
+exports.toPrismaId = toPrismaId;
+class InvalidPrismaIdError extends Error {
+    constructor(id) {
+        super(`Invalid Prisma integer id: ${JSON.stringify(id)}`);
+    }
+}
+exports.InvalidPrismaIdError = InvalidPrismaIdError;
+function isModelId(value) {
+    return typeof value === 'number' || typeof value === 'string';
+}
+function toPrismaId(id) {
+    if (id === null || id === undefined) {
+        return id;
+    }
+    if (typeof id === 'number') {
+        if (Number.isSafeInteger(id)) {
+            return id;
+        }
+        throw new InvalidPrismaIdError(id);
+    }
+    if (/^-?\d+$/.test(id)) {
+        const numericId = Number(id);
+        if (Number.isSafeInteger(numericId)) {
+            return numericId;
+        }
+    }
+    throw new InvalidPrismaIdError(id);
+}

package/dist/storage-handlers/delete-handlers/group.d.ts

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
+import { DataTypes } from 'brackets-model';
 import { PrismaClient } from '@prisma/client';
 export declare function handleGroupDelete(prisma: PrismaClient, filter?: Partial<DataTypes['group']>): Promise<boolean>;

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

@@ -1,23 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGroupDelete = void 0;
+exports.handleGroupDelete = handleGroupDelete;
+const prisma_id_1 = require("../../prisma-id");
 async function handleGroupDelete(prisma, filter) {
     // No filter so delete everything
     if (!filter) {
-        return prisma.group
-            .deleteMany({})
-            .then(() => true)
-            .catch(() => false);
+        try {
+            await prisma.group.deleteMany({});
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    return prisma.group
-        .deleteMany({
-        where: {
-            id: filter.id,
-            stageId: filter.stage_id,
+    try {
+        const where = {
+            id: (0, prisma_id_1.toPrismaId)(filter.id),
+            stageId: (0, prisma_id_1.toPrismaId)(filter.stage_id),
             number: filter.number,
-        },
-    })
-        .then(() => true)
-        .catch(() => false);
+        };
+        await prisma.group.deleteMany({ where });
+        return true;
+    }
+    catch (error) {
+        // An unsupported storage ID should behave like a filter that matched no rows.
+        if (error instanceof prisma_id_1.InvalidPrismaIdError) {
+            return true;
+        }
+        return false;
+    }
 }
-exports.handleGroupDelete = handleGroupDelete;

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
+import { DataTypes } from 'brackets-model';
 import { PrismaClient } from '@prisma/client';
 export declare function handleMatchGameDelete(prisma: PrismaClient, filter?: Partial<DataTypes['match_game']>): Promise<boolean>;

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

@@ -1,28 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleMatchGameDelete = void 0;
+exports.handleMatchGameDelete = handleMatchGameDelete;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 async function handleMatchGameDelete(prisma, filter) {
     // No filter so delete everything
     if (!filter) {
-        return prisma.matchGame
-            .deleteMany({})
-            .then(() => true)
-            .catch(() => false);
+        try {
+            await prisma.matchGame.deleteMany({});
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    return prisma.matchGame
-        .deleteMany({
-        where: {
-            id: filter.id,
-            stageId: filter.stage_id,
-            matchId: filter.parent_id,
+    try {
+        const where = {
+            id: (0, prisma_id_1.toPrismaId)(filter.id),
+            stageId: (0, prisma_id_1.toPrismaId)(filter.stage_id),
+            matchId: (0, prisma_id_1.toPrismaId)(filter.parent_id),
             number: filter.number,
             status: filter.status
                 ? transformers_1.MatchStatusTransformer.to(filter.status)
                 : undefined,
-        },
-    })
-        .then(() => true)
-        .catch(() => false);
+        };
+        await prisma.matchGame.deleteMany({ where });
+        return true;
+    }
+    catch (error) {
+        // An unsupported storage ID should behave like a filter that matched no rows.
+        if (error instanceof prisma_id_1.InvalidPrismaIdError) {
+            return true;
+        }
+        return false;
+    }
 }
-exports.handleMatchGameDelete = handleMatchGameDelete;

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
+import { DataTypes } from 'brackets-model';
 import { PrismaClient } from '@prisma/client';
 export declare function handleMatchDelete(prisma: PrismaClient, filter?: Partial<DataTypes['match']>): Promise<boolean>;

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

@@ -1,29 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleMatchDelete = void 0;
+exports.handleMatchDelete = handleMatchDelete;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 async function handleMatchDelete(prisma, filter) {
     // No filter so delete everything
     if (!filter) {
-        return prisma.match
-            .deleteMany({})
-            .then(() => true)
-            .catch(() => false);
+        try {
+            await prisma.match.deleteMany({});
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    return prisma.match
-        .deleteMany({
-        where: {
-            id: filter.id,
-            stageId: filter.stage_id,
-            groupId: filter.group_id,
-            roundId: filter.round_id,
+    try {
+        const where = {
+            id: (0, prisma_id_1.toPrismaId)(filter.id),
+            stageId: (0, prisma_id_1.toPrismaId)(filter.stage_id),
+            groupId: (0, prisma_id_1.toPrismaId)(filter.group_id),
+            roundId: (0, prisma_id_1.toPrismaId)(filter.round_id),
             number: filter.number,
             status: filter.status
                 ? transformers_1.MatchStatusTransformer.to(filter.status)
                 : undefined,
-        },
-    })
-        .then(() => true)
-        .catch(() => false);
+        };
+        await prisma.match.deleteMany({ where });
+        return true;
+    }
+    catch (error) {
+        // An unsupported storage ID should behave like a filter that matched no rows.
+        if (error instanceof prisma_id_1.InvalidPrismaIdError) {
+            return true;
+        }
+        return false;
+    }
 }
-exports.handleMatchDelete = handleMatchDelete;

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

@@ -1,3 +1,3 @@
 import { PrismaClient } from '@prisma/client';
-import { DataTypes } from 'brackets-manager/dist/types';
+import { DataTypes } from 'brackets-model';
 export declare function handleParticipantDelete(prisma: PrismaClient, filter?: Partial<DataTypes['participant']>): Promise<boolean>;

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

@@ -1,23 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleParticipantDelete = void 0;
+exports.handleParticipantDelete = handleParticipantDelete;
+const prisma_id_1 = require("../../prisma-id");
 async function handleParticipantDelete(prisma, filter) {
     // No filter so delete everything
     if (!filter) {
-        return prisma.participant
-            .deleteMany({})
-            .then(() => true)
-            .catch(() => false);
+        try {
+            await prisma.participant.deleteMany({});
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    return prisma.participant
-        .deleteMany({
-        where: {
-            id: filter.id,
+    try {
+        const where = {
+            id: (0, prisma_id_1.toPrismaId)(filter.id),
             name: filter.name,
-            tournamentId: filter.tournament_id,
-        },
-    })
-        .then(() => true)
-        .catch(() => false);
+            tournamentId: (0, prisma_id_1.toPrismaId)(filter.tournament_id),
+        };
+        await prisma.participant.deleteMany({ where });
+        return true;
+    }
+    catch (error) {
+        // An unsupported storage ID should behave like a filter that matched no rows.
+        if (error instanceof prisma_id_1.InvalidPrismaIdError) {
+            return true;
+        }
+        return false;
+    }
 }
-exports.handleParticipantDelete = handleParticipantDelete;

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
+import { DataTypes } from 'brackets-model';
 import { PrismaClient } from '@prisma/client';
 export declare function handleRoundDelete(prisma: PrismaClient, filter?: Partial<DataTypes['round']>): Promise<boolean>;

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

@@ -1,24 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRoundDelete = void 0;
+exports.handleRoundDelete = handleRoundDelete;
+const prisma_id_1 = require("../../prisma-id");
 async function handleRoundDelete(prisma, filter) {
     // No filter so delete everything
     if (!filter) {
-        return prisma.round
-            .deleteMany({})
-            .then(() => true)
-            .catch(() => false);
+        try {
+            await prisma.round.deleteMany({});
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    return prisma.round
-        .deleteMany({
-        where: {
-            id: filter.id,
-            stageId: filter.stage_id,
-            groupId: filter.group_id,
+    try {
+        const where = {
+            id: (0, prisma_id_1.toPrismaId)(filter.id),
+            stageId: (0, prisma_id_1.toPrismaId)(filter.stage_id),
+            groupId: (0, prisma_id_1.toPrismaId)(filter.group_id),
             number: filter.number,
-        },
-    })
-        .then(() => true)
-        .catch(() => false);
+        };
+        await prisma.round.deleteMany({ where });
+        return true;
+    }
+    catch (error) {
+        // An unsupported storage ID should behave like a filter that matched no rows.
+        if (error instanceof prisma_id_1.InvalidPrismaIdError) {
+            return true;
+        }
+        return false;
+    }
 }
-exports.handleRoundDelete = handleRoundDelete;

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
+import { DataTypes } from 'brackets-model';
 import { PrismaClient } from '@prisma/client';
 export declare function handleStageDelete(prisma: PrismaClient, filter?: Partial<DataTypes['stage']>): Promise<boolean>;

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

@@ -1,47 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleStageDelete = void 0;
+exports.handleStageDelete = handleStageDelete;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 async function handleStageDelete(prisma, filter) {
-    return prisma
-        .$transaction(async (tx) => {
-        // Build where clause if a filter is provided
+    try {
         const where = filter
             ? {
-                id: filter.id,
+                id: (0, prisma_id_1.toPrismaId)(filter.id),
                 name: filter.name,
                 number: filter.number,
-                tournamentId: filter.tournament_id,
+                tournamentId: (0, prisma_id_1.toPrismaId)(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)
+        await prisma.$transaction(async (tx) => {
+            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;
-        // 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((e) => {
-        console.error(new Error(`Error deleting stages with filter ${JSON.stringify(filter)}`, { cause: e }));
+    }
+    catch (error) {
+        // An unsupported storage ID should behave like a filter that matched no rows.
+        if (error instanceof prisma_id_1.InvalidPrismaIdError) {
+            return true;
+        }
         return false;
-    });
+    }
 }
-exports.handleStageDelete = handleStageDelete;

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

@@ -1,3 +1,3 @@
-import { DataTypes } from 'brackets-manager/dist/types';
+import { DataTypes } from 'brackets-model';
 import { PrismaClient } from '@prisma/client';
 export declare function handleDelete<T extends keyof DataTypes>(prisma: PrismaClient, table: T, filter?: Partial<DataTypes[T]>): Promise<boolean>;

package/dist/storage-handlers/delete.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleDelete = void 0;
+exports.handleDelete = handleDelete;
 const delete_handlers_1 = require("./delete-handlers");
 // Can't be named `delete` because its a reserved word...
 async function handleDelete(prisma, table, filter) {
@@ -21,4 +21,3 @@ async function handleDelete(prisma, table, filter) {
             return false;
     }
 }
-exports.handleDelete = handleDelete;

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

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

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

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGroupInsert = void 0;
+exports.handleGroupInsert = handleGroupInsert;
 const transformers_1 = require("../../transformers");
-function handleGroupInsert(prisma, values) {
-    if (Array.isArray(values)) {
-        return prisma.group
-            .createMany({
-            data: values.map(transformers_1.GroupTransformer.to),
-        })
-            .then(() => true)
-            .catch(() => false);
+async function handleGroupInsert(prisma, values) {
+    try {
+        if (Array.isArray(values)) {
+            await prisma.group.createMany({
+                data: values.map(transformers_1.GroupTransformer.to),
+            });
+            return true;
+        }
+        const group = await prisma.group.create({
+            data: transformers_1.GroupTransformer.to(values),
+        });
+        return group.id;
+    }
+    catch {
+        return Array.isArray(values) ? false : -1;
     }
-    return prisma.group
-        .create({
-        data: transformers_1.GroupTransformer.to(values),
-    })
-        .then((v) => v.id)
-        .catch(() => -1);
 }
-exports.handleGroupInsert = handleGroupInsert;

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-model';
 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 | boolean>;

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

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleMatchGameInsert = void 0;
+exports.handleMatchGameInsert = handleMatchGameInsert;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 function getCreationData(value) {
     return {
         ...transformers_1.MatchGameTransformer.to(value),
+        extra: value.extra ?? undefined,
         opponent1Result: value.opponent1
             ? {
                 create: {
-                    participantId: value.opponent1.id,
+                    participantId: (0, prisma_id_1.toPrismaId)(value.opponent1.id),
                     forfeit: value.opponent1.forfeit,
                     position: value.opponent1.position,
                     score: value.opponent1.score,
@@ -21,7 +23,7 @@ function getCreationData(value) {
         opponent2Result: value.opponent2
             ? {
                 create: {
-                    participantId: value.opponent2.id,
+                    participantId: (0, prisma_id_1.toPrismaId)(value.opponent2.id),
                     forfeit: value.opponent2.forfeit,
                     position: value.opponent2.position,
                     score: value.opponent2.score,
@@ -33,20 +35,20 @@ function getCreationData(value) {
             : undefined,
     };
 }
-function handleMatchGameInsert(prisma, values) {
-    if (Array.isArray(values)) {
-        return prisma.matchGame
-            .createMany({
-            data: values.map((v) => getCreationData(v)),
-        })
-            .then(() => true)
-            .catch(() => false);
+async function handleMatchGameInsert(prisma, values) {
+    try {
+        if (Array.isArray(values)) {
+            await prisma.matchGame.createMany({
+                data: values.map((v) => getCreationData(v)),
+            });
+            return true;
+        }
+        const matchGame = await prisma.matchGame.create({
+            data: getCreationData(values),
+        });
+        return matchGame.id;
+    }
+    catch {
+        return Array.isArray(values) ? false : -1;
     }
-    return prisma.matchGame
-        .create({
-        data: getCreationData(values),
-    })
-        .then((v) => v.id)
-        .catch(() => -1);
 }
-exports.handleMatchGameInsert = handleMatchGameInsert;