brackets-prisma-db 2.1.0 → 2.1.1

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleMatchInsert = void 0;
+exports.handleMatchInsert = handleMatchInsert;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 function getCreationData(value) {
     return {
         ...transformers_1.MatchTransformer.to(value),
@@ -9,7 +10,7 @@ function getCreationData(value) {
         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,
@@ -22,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,
@@ -34,20 +35,20 @@ function getCreationData(value) {
             : undefined,
     };
 }
-function handleMatchInsert(prisma, values) {
-    if (Array.isArray(values)) {
-        return prisma.match
-            .createMany({
-            data: values.map((v) => getCreationData(v)),
-        })
-            .then(() => true)
-            .catch(() => false);
+async function handleMatchInsert(prisma, values) {
+    try {
+        if (Array.isArray(values)) {
+            await prisma.match.createMany({
+                data: values.map((v) => getCreationData(v)),
+            });
+            return true;
+        }
+        const match = await prisma.match.create({
+            data: getCreationData(values),
+        });
+        return match.id;
+    }
+    catch {
+        return Array.isArray(values) ? false : -1;
     }
-    return prisma.match
-        .create({
-        data: getCreationData(values),
-    })
-        .then((v) => v.id)
-        .catch(() => -1);
 }
-exports.handleMatchInsert = handleMatchInsert;

package/dist/storage-handlers/insert-handlers/participant.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 handleParticipantInsert(prisma: PrismaClient, values: OmitId<DataTypes['participant']> | OmitId<DataTypes['participant']>[]): Promise<number> | Promise<boolean>;
+export declare function handleParticipantInsert(prisma: PrismaClient, values: OmitId<DataTypes['participant']> | OmitId<DataTypes['participant']>[]): Promise<number | boolean>;

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

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

package/dist/storage-handlers/insert-handlers/round.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 handleRoundInsert(prisma: PrismaClient, values: OmitId<DataTypes['round']> | OmitId<DataTypes['round']>[]): Promise<number> | Promise<boolean>;
+export declare function handleRoundInsert(prisma: PrismaClient, values: OmitId<DataTypes['round']> | OmitId<DataTypes['round']>[]): Promise<number | boolean>;

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

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

package/dist/storage-handlers/insert-handlers/stage.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 handleStageInsert(prisma: PrismaClient, values: OmitId<DataTypes['stage']> | OmitId<DataTypes['stage']>[]): Promise<number> | Promise<boolean>;
+export declare function handleStageInsert(prisma: PrismaClient, values: OmitId<DataTypes['stage']> | OmitId<DataTypes['stage']>[]): Promise<number | boolean>;

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

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

package/dist/storage-handlers/insert.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 handleInsert<T extends keyof DataTypes>(prisma: PrismaClient, table: T, values: OmitId<DataTypes[T]> | OmitId<DataTypes[T]>[]): Promise<number | boolean>;

package/dist/storage-handlers/insert.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleInsert = void 0;
+exports.handleInsert = handleInsert;
 const insert_handlers_1 = require("./insert-handlers");
 async function handleInsert(prisma, table, values) {
     switch (table) {
@@ -26,4 +26,3 @@ async function handleInsert(prisma, table, values) {
             return false;
     }
 }
-exports.handleInsert = handleInsert;

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

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

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

@@ -1,42 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGroupSelect = void 0;
-// @ts-ignore
+exports.handleGroupSelect = handleGroupSelect;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 async function handleGroupSelect(prisma, filter) {
     if (filter === undefined) {
         // Query all entries of table
-        return prisma.group
-            .findMany({
-            orderBy: [{ number: 'asc' }],
-        })
-            .then((values) => values.map(transformers_1.GroupTransformer.from))
-            .catch(() => []);
+        try {
+            const values = await prisma.group.findMany({
+                orderBy: [{ number: 'asc' }],
+            });
+            return values.map(transformers_1.GroupTransformer.from);
+        }
+        catch {
+            return [];
+        }
     }
-    if (typeof filter === 'number') {
+    if ((0, prisma_id_1.isModelId)(filter)) {
         // Find by Id
-        return prisma.group
-            .findFirst({
-            where: { id: filter },
-        })
-            .then((value) => {
+        try {
+            const value = await prisma.group.findFirst({
+                where: { id: (0, prisma_id_1.toPrismaId)(filter) },
+            });
             if (value === null) {
                 return null;
             }
             return transformers_1.GroupTransformer.from(value);
-        })
-            .catch(() => null);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const values = await prisma.group.findMany({
+            where: {
+                id: (0, prisma_id_1.toPrismaId)(filter.id),
+                stageId: (0, prisma_id_1.toPrismaId)(filter.stage_id),
+                number: filter.number,
+            },
+            orderBy: [{ number: 'asc' }],
+        });
+        return values.map(transformers_1.GroupTransformer.from);
+    }
+    catch {
+        return [];
     }
-    return prisma.group
-        .findMany({
-        where: {
-            id: filter.id,
-            stageId: filter.stage_id,
-            number: filter.number,
-        },
-        orderBy: [{ number: 'asc' }],
-    })
-        .then((values) => values.map(transformers_1.GroupTransformer.from))
-        .catch(() => []);
 }
-exports.handleGroupSelect = handleGroupSelect;

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

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

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

@@ -1,55 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleMatchGameSelect = void 0;
+exports.handleMatchGameSelect = handleMatchGameSelect;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 async function handleMatchGameSelect(prisma, filter) {
     if (filter === undefined) {
-        return prisma.matchGame
-            .findMany({
+        try {
+            const values = await prisma.matchGame.findMany({
+                include: {
+                    opponent1Result: true,
+                    opponent2Result: true,
+                },
+                orderBy: [{ number: 'asc' }],
+            });
+            return values.map(transformers_1.MatchGameTransformer.from);
+        }
+        catch {
+            return [];
+        }
+    }
+    if ((0, prisma_id_1.isModelId)(filter)) {
+        try {
+            const value = await prisma.matchGame.findFirst({
+                where: { id: (0, prisma_id_1.toPrismaId)(filter) },
+                include: {
+                    opponent1Result: true,
+                    opponent2Result: true,
+                },
+            });
+            if (value === null) {
+                return null;
+            }
+            return transformers_1.MatchGameTransformer.from(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const values = await prisma.matchGame.findMany({
+            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,
+            },
             include: {
                 opponent1Result: true,
                 opponent2Result: true,
             },
             orderBy: [{ number: 'asc' }],
-        })
-            .then((values) => values.map(transformers_1.MatchGameTransformer.from))
-            .catch(() => []);
+        });
+        return values.map(transformers_1.MatchGameTransformer.from);
     }
-    if (typeof filter === 'number') {
-        return prisma.matchGame
-            .findFirst({
-            where: { id: filter },
-            include: {
-                opponent1Result: true,
-                opponent2Result: true,
-            },
-        })
-            .then((value) => {
-            if (value === null) {
-                return null;
-            }
-            return transformers_1.MatchGameTransformer.from(value);
-        })
-            .catch(() => null);
+    catch {
+        return [];
     }
-    return prisma.matchGame
-        .findMany({
-        where: {
-            id: filter.id,
-            stageId: filter.stage_id,
-            matchId: filter.parent_id,
-            number: filter.number,
-            status: filter.status
-                ? transformers_1.MatchStatusTransformer.to(filter.status)
-                : undefined,
-        },
-        include: {
-            opponent1Result: true,
-            opponent2Result: true,
-        },
-        orderBy: [{ number: 'asc' }],
-    })
-        .then((values) => values.map(transformers_1.MatchGameTransformer.from))
-        .catch(() => []);
 }
-exports.handleMatchGameSelect = handleMatchGameSelect;

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

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

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

@@ -1,11 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleMatchSelect = void 0;
+exports.handleMatchSelect = handleMatchSelect;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 async function handleMatchSelect(prisma, filter) {
     if (filter === undefined) {
-        return prisma.match
-            .findMany({
+        try {
+            const values = await prisma.match.findMany({
+                include: {
+                    opponent1Result: true,
+                    opponent2Result: true,
+                },
+                orderBy: [
+                    {
+                        round: {
+                            number: 'asc',
+                        },
+                    },
+                    { number: 'asc' },
+                ],
+            });
+            return values.map(transformers_1.MatchTransformer.from);
+        }
+        catch {
+            return [];
+        }
+    }
+    if ((0, prisma_id_1.isModelId)(filter)) {
+        // Find by Id
+        try {
+            const value = await prisma.match.findFirst({
+                where: { id: (0, prisma_id_1.toPrismaId)(filter) },
+                include: {
+                    opponent1Result: true,
+                    opponent2Result: true,
+                },
+            });
+            if (value === null) {
+                return null;
+            }
+            return transformers_1.MatchTransformer.from(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const values = await prisma.match.findMany({
+            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,
+                childCount: filter.child_count,
+            },
             include: {
                 opponent1Result: true,
                 opponent2Result: true,
@@ -18,55 +70,10 @@ async function handleMatchSelect(prisma, filter) {
                 },
                 { number: 'asc' },
             ],
-        })
-            .then((values) => values.map(transformers_1.MatchTransformer.from))
-            .catch(() => []);
+        });
+        return values.map(transformers_1.MatchTransformer.from);
     }
-    if (typeof filter === 'number') {
-        // Find by Id
-        return prisma.match
-            .findFirst({
-            where: { id: filter },
-            include: {
-                opponent1Result: true,
-                opponent2Result: true,
-            },
-        })
-            .then((value) => {
-            if (value === null) {
-                return null;
-            }
-            return transformers_1.MatchTransformer.from(value);
-        })
-            .catch(() => null);
+    catch {
+        return [];
     }
-    return prisma.match
-        .findMany({
-        where: {
-            id: filter.id,
-            stageId: filter.stage_id,
-            groupId: filter.group_id,
-            roundId: filter.round_id,
-            number: filter.number,
-            status: filter.status
-                ? transformers_1.MatchStatusTransformer.to(filter.status)
-                : undefined,
-            childCount: filter.child_count,
-        },
-        include: {
-            opponent1Result: true,
-            opponent2Result: true,
-        },
-        orderBy: [
-            {
-                round: {
-                    number: 'asc',
-                },
-            },
-            { number: 'asc' },
-        ],
-    })
-        .then((values) => values.map(transformers_1.MatchTransformer.from))
-        .catch(() => []);
 }
-exports.handleMatchSelect = handleMatchSelect;

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

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

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

@@ -1,38 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleParticipantSelect = void 0;
+exports.handleParticipantSelect = handleParticipantSelect;
 const transformers_1 = require("../../transformers");
+const prisma_id_1 = require("../../prisma-id");
 async function handleParticipantSelect(prisma, filter) {
     if (filter === undefined) {
         // Query all entries of table
-        return prisma.participant
-            .findMany()
-            .then((values) => values.map(transformers_1.ParticipantTransformer.from))
-            .catch(() => []);
+        try {
+            const values = await prisma.participant.findMany();
+            return values.map(transformers_1.ParticipantTransformer.from);
+        }
+        catch {
+            return [];
+        }
     }
-    if (typeof filter === 'number') {
+    if ((0, prisma_id_1.isModelId)(filter)) {
         // Find by Id
-        return prisma.participant
-            .findFirst({
-            where: { id: filter },
-        })
-            .then((value) => {
+        try {
+            const value = await prisma.participant.findFirst({
+                where: { id: (0, prisma_id_1.toPrismaId)(filter) },
+            });
             if (value === null) {
                 return null;
             }
             return transformers_1.ParticipantTransformer.from(value);
-        })
-            .catch(() => null);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const values = await prisma.participant.findMany({
+            where: {
+                id: (0, prisma_id_1.toPrismaId)(filter.id),
+                name: filter.name,
+                tournamentId: (0, prisma_id_1.toPrismaId)(filter.tournament_id),
+            },
+        });
+        return values.map(transformers_1.ParticipantTransformer.from);
+    }
+    catch {
+        return [];
     }
-    return prisma.participant
-        .findMany({
-        where: {
-            id: filter.id,
-            name: filter.name,
-            tournamentId: filter.tournament_id,
-        },
-    })
-        .then((values) => values.map(transformers_1.ParticipantTransformer.from))
-        .catch(() => []);
 }
-exports.handleParticipantSelect = handleParticipantSelect;

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

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