brackets-prisma-db 1.0.0

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

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

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

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

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

@@ -0,0 +1,6 @@
+export * from './group';
+export * from './match';
+export * from './match-game';
+export * from './participant';
+export * from './round';
+export * from './stage';

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

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./group"), exports);
+__exportStar(require("./match"), exports);
+__exportStar(require("./match-game"), exports);
+__exportStar(require("./participant"), exports);
+__exportStar(require("./round"), exports);
+__exportStar(require("./stage"), exports);

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

@@ -0,0 +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>;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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: {
+                opponent1Result: true,
+                opponent2Result: true,
+            },
+        })
+            .then((values) => values.map(transformers_1.MatchGameTransformer.from))
+            .catch(() => []);
+    }
+    if (typeof filter === 'number') {
+        // Find by Id
+        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);
+    }
+    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,
+        },
+    })
+        .then((values) => values.map(transformers_1.MatchGameTransformer.from))
+        .catch(() => []);
+}
+exports.handleMatchGameSelect = handleMatchGameSelect;

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

@@ -0,0 +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>;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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: {
+                opponent1Result: true,
+                opponent2Result: true,
+            },
+        })
+            .then((values) => values.map(transformers_1.MatchTransformer.from))
+            .catch(() => []);
+    }
+    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);
+    }
+    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,
+        },
+    })
+        .then((values) => values.map(transformers_1.MatchTransformer.from))
+        .catch(() => []);
+}
+exports.handleMatchSelect = handleMatchSelect;

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

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

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParticipantSelect = void 0;
+const transformers_1 = require("../../transformers");
+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(() => []);
+    }
+    if (typeof filter === 'number') {
+        // Find by Id
+        return prisma.participant
+            .findFirst({
+            where: { id: filter },
+        })
+            .then((value) => {
+            if (value === null) {
+                return null;
+            }
+            return transformers_1.ParticipantTransformer.from(value);
+        })
+            .catch(() => null);
+    }
+    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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRoundSelect = void 0;
+const transformers_1 = require("../../transformers");
+async function handleRoundSelect(prisma, filter) {
+    if (filter === undefined) {
+        // Query all entries of table
+        return prisma.round
+            .findMany()
+            .then((values) => values.map(transformers_1.RoundTransformer.from))
+            .catch(() => []);
+    }
+    if (typeof filter === 'number') {
+        // Find by Id
+        return prisma.round
+            .findFirst({
+            where: { id: filter },
+        })
+            .then((value) => {
+            if (value === null) {
+                return null;
+            }
+            return transformers_1.RoundTransformer.from(value);
+        })
+            .catch(() => null);
+    }
+    return prisma.round
+        .findMany({
+        where: {
+            id: filter.id,
+            stageId: filter.stage_id,
+            groupId: filter.group_id,
+            number: filter.number,
+        },
+    })
+        .then((values) => values.map(transformers_1.RoundTransformer.from))
+        .catch(() => []);
+}
+exports.handleRoundSelect = handleRoundSelect;

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

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

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStageSelect = void 0;
+const transformers_1 = require("../../transformers");
+async function handleStageSelect(prisma, filter) {
+    if (filter === undefined) {
+        // Query all entries of table
+        return prisma.stage
+            .findMany({
+            include: {
+                settings: true,
+            },
+        })
+            .then((values) => values.map((value) => {
+            if (value.settings === null) {
+                throw Error(`Stage didn't have a Settings Relation attached.`);
+            }
+            return transformers_1.StageTransformer.from(value);
+        }))
+            .catch(() => []);
+    }
+    if (typeof filter === 'number') {
+        // Find by Id
+        return prisma.stage
+            .findFirst({
+            where: { id: filter },
+            include: {
+                settings: true,
+            },
+        })
+            .then((value) => {
+            if (value === null) {
+                return null;
+            }
+            if (value.settings === null) {
+                throw Error(`Stage didn't have a Settings Relation attached.`);
+            }
+            return transformers_1.StageTransformer.from(value);
+        })
+            .catch(() => null);
+    }
+    return prisma.stage
+        .findMany({
+        where: {
+            id: filter.id,
+            name: filter.name,
+            tournamentId: filter.tournament_id,
+            number: filter.number,
+            type: filter.type
+                ? transformers_1.StageTypeTransformer.to(filter.type)
+                : undefined,
+        },
+        include: {
+            settings: true,
+        },
+    })
+        .then((values) => values.map((value) => {
+        if (value.settings === null) {
+            throw Error(`Stage didn't have a Settings Relation attached.`);
+        }
+        return transformers_1.StageTransformer.from(value);
+    }))
+        .catch(() => []);
+}
+exports.handleStageSelect = handleStageSelect;

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

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

package/dist/storage-handlers/select.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSelect = void 0;
+const select_handlers_1 = require("./select-handlers");
+async function handleSelect(prisma, table, filter) {
+    switch (table) {
+        case 'participant':
+            return (0, select_handlers_1.handleParticipantSelect)(prisma, filter);
+        case 'stage':
+            return (0, select_handlers_1.handleStageSelect)(prisma, filter);
+        case 'group':
+            return (0, select_handlers_1.handleGroupSelect)(prisma, filter);
+        case 'round':
+            return (0, select_handlers_1.handleRoundSelect)(prisma, filter);
+        case 'match':
+            return (0, select_handlers_1.handleMatchSelect)(prisma, filter);
+        case 'match_game':
+            return (0, select_handlers_1.handleMatchGameSelect)(prisma, filter);
+        default:
+            return null;
+    }
+}
+exports.handleSelect = handleSelect;

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

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

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGroupUpdate = void 0;
+async function handleGroupUpdate(prisma, filter, value) {
+    if (typeof filter === 'number') {
+        // Update by Id
+        return prisma.group
+            .update({
+            where: {
+                id: filter,
+            },
+            data: {
+                number: value.number,
+                stageId: value.stage_id,
+            },
+        })
+            .then(() => true)
+            .catch(() => false);
+    }
+    // Update by filter
+    return prisma.group
+        .updateMany({
+        where: {
+            id: filter.id,
+            number: filter.number,
+            stageId: filter.stage_id,
+        },
+        data: {
+            number: value.number,
+            stageId: value.stage_id,
+        },
+    })
+        .then(() => true)
+        .catch(() => false);
+}
+exports.handleGroupUpdate = handleGroupUpdate;

package/dist/storage-handlers/update-handlers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './group';
+export * from './match';
+export * from './match-game';
+export * from './participant';
+export * from './round';
+export * from './stage';

package/dist/storage-handlers/update-handlers/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./group"), exports);
+__exportStar(require("./match"), exports);
+__exportStar(require("./match-game"), exports);
+__exportStar(require("./participant"), exports);
+__exportStar(require("./round"), exports);
+__exportStar(require("./stage"), exports);

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

@@ -0,0 +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>;

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchGameUpdate = void 0;
+const transformers_1 = require("../../transformers");
+function getParticipantResultUpsertData(value) {
+    return {
+        upsert: {
+            update: {
+                participantId: value.id,
+                forfeit: value.forfeit,
+                position: value.position,
+                score: value.score,
+                result: value.result
+                    ? transformers_1.MatchResultTransformer.to(value.result)
+                    : undefined,
+            },
+            create: {
+                participantId: value.id,
+                forfeit: value.forfeit,
+                position: value.position,
+                score: value.score,
+                result: value.result
+                    ? transformers_1.MatchResultTransformer.to(value.result)
+                    : undefined,
+            },
+        },
+    };
+}
+function getUpdateData(value) {
+    return {
+        stageId: value.stage_id,
+        matchId: value.parent_id,
+        number: value.number,
+        status: value.status
+            ? transformers_1.MatchStatusTransformer.to(value.status)
+            : undefined,
+        opponent1Result: value.opponent1
+            ? getParticipantResultUpsertData(value.opponent1)
+            : undefined,
+        opponent2Result: value.opponent2
+            ? getParticipantResultUpsertData(value.opponent2)
+            : undefined,
+    };
+}
+function updateById(prisma, id, value) {
+    return prisma.matchGame.update({
+        where: {
+            id,
+        },
+        data: getUpdateData(value),
+    });
+}
+async function handleMatchGameUpdate(prisma, filter, value) {
+    if (typeof filter === 'number') {
+        // Update by Id
+        return updateById(prisma, filter, value)
+            .then(() => true)
+            .catch(() => 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

@@ -0,0 +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>;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchUpdate = void 0;
+const transformers_1 = require("../../transformers");
+function getParticipantResultUpsertData(value) {
+    return {
+        upsert: {
+            update: {
+                participantId: value.id,
+                forfeit: value.forfeit,
+                position: value.position,
+                score: value.score,
+                result: value.result
+                    ? transformers_1.MatchResultTransformer.to(value.result)
+                    : undefined,
+            },
+            create: {
+                participantId: value.id,
+                forfeit: value.forfeit,
+                position: value.position,
+                score: value.score,
+                result: value.result
+                    ? transformers_1.MatchResultTransformer.to(value.result)
+                    : undefined,
+            },
+        },
+    };
+}
+function getUpdateData(value) {
+    return {
+        stageId: value.stage_id,
+        groupId: value.group_id,
+        roundId: value.round_id,
+        childCount: value.child_count,
+        number: value.number,
+        status: value.status
+            ? transformers_1.MatchStatusTransformer.to(value.status)
+            : undefined,
+        opponent1Result: value.opponent1
+            ? getParticipantResultUpsertData(value.opponent1)
+            : undefined,
+        opponent2Result: value.opponent2
+            ? getParticipantResultUpsertData(value.opponent2)
+            : undefined,
+    };
+}
+function updateById(prisma, id, value) {
+    return prisma.match.update({
+        where: {
+            id,
+        },
+        data: getUpdateData(value),
+    });
+}
+async function handleMatchUpdate(prisma, filter, value) {
+    if (typeof filter === 'number') {
+        // Update by Id
+        return updateById(prisma, filter, value)
+            .then(() => true)
+            .catch(() => 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.d.ts

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