brackets-prisma-db 1.0.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStageUpdate = void 0;
+const transformers_1 = require("../../transformers");
+async function handleStageUpdate(prisma, filter, value) {
+    if (typeof filter !== 'number') {
+        return false;
+    }
+    return prisma.stage
+        .update({
+        where: {
+            id: filter,
+        },
+        data: {
+            name: value.name,
+            number: value.number,
+            tournamentId: value.tournament_id,
+            type: value.type
+                ? transformers_1.StageTypeTransformer.to(value.type)
+                : undefined,
+            settings: value.settings
+                ? {
+                    update: {
+                        size: value.settings.size,
+                        seedOrdering: value.settings.seedOrdering
+                            ? value.settings.seedOrdering.map(transformers_1.SeedOrderingTransformer.to)
+                            : undefined,
+                        balanceByes: value.settings.balanceByes,
+                        matchesChildCount: value.settings.matchesChildCount,
+                        groupCount: value.settings.groupCount,
+                        roundRobinMode: value.settings.roundRobinMode
+                            ? transformers_1.RoundRobinModeTransformer.to(value.settings.roundRobinMode)
+                            : undefined,
+                        manualOrdering: value.settings.manualOrdering
+                            ? JSON.stringify(value.settings.manualOrdering)
+                            : undefined,
+                        consolationFinal: value.settings.consolationFinal,
+                        skipFirstRound: value.settings.skipFirstRound,
+                        grandFinal: value.settings.grandFinal
+                            ? transformers_1.GrandFinalTypeTransformer.to(value.settings.grandFinal)
+                            : undefined,
+                    },
+                }
+                : undefined,
+        },
+    })
+        .then(() => true)
+        .catch(() => false);
+}
+exports.handleStageUpdate = handleStageUpdate;

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

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

package/dist/storage-handlers/update.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpdate = void 0;
+const update_handlers_1 = require("./update-handlers");
+async function handleUpdate(prisma, table, filter, value) {
+    switch (table) {
+        case 'participant':
+            return (0, update_handlers_1.handleParticipantUpdate)(prisma, filter, value);
+        case 'stage':
+            return (0, update_handlers_1.handleStageUpdate)(prisma, filter, value);
+        case 'group':
+            return (0, update_handlers_1.handleGroupUpdate)(prisma, filter, value);
+        case 'round':
+            return (0, update_handlers_1.handleRoundUpdate)(prisma, filter, value);
+        case 'match':
+            return (0, update_handlers_1.handleMatchUpdate)(prisma, filter, value);
+        case 'match_game':
+            return (0, update_handlers_1.handleMatchGameUpdate)(prisma, filter, value);
+        default:
+            return false;
+    }
+}
+exports.handleUpdate = handleUpdate;

package/dist/storage.d.ts

@@ -0,0 +1,16 @@
+import { CrudInterface, OmitId } from 'brackets-manager';
+import { DataTypes } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare class SqlDatabase implements CrudInterface {
+    private prisma;
+    constructor(prisma: PrismaClient);
+    insert<T extends keyof DataTypes>(table: T, value: OmitId<DataTypes[T]>): Promise<number>;
+    insert<T extends keyof DataTypes>(table: T, values: OmitId<DataTypes[T]>[]): Promise<boolean>;
+    select<T extends keyof DataTypes>(table: T): Promise<DataTypes[T][] | null>;
+    select<T extends keyof DataTypes>(table: T, id: number): Promise<DataTypes[T] | null>;
+    select<T extends keyof DataTypes>(table: T, filter: Partial<DataTypes[T]>): Promise<DataTypes[T][] | null>;
+    update<T extends keyof DataTypes>(table: T, id: number, value: DataTypes[T]): Promise<boolean>;
+    update<T extends keyof DataTypes>(table: T, filter: Partial<DataTypes[T]>, value: Partial<DataTypes[T]>): Promise<boolean>;
+    delete<T extends keyof DataTypes>(table: T): Promise<boolean>;
+    delete<T extends keyof DataTypes>(table: T, filter: Partial<DataTypes[T]>): Promise<boolean>;
+}

package/dist/storage.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlDatabase = void 0;
+const storage_handlers_1 = require("./storage-handlers");
+class SqlDatabase {
+    prisma;
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    insert(table, values) {
+        return (0, storage_handlers_1.handleInsert)(this.prisma, table, values);
+    }
+    select(table, filter) {
+        return (0, storage_handlers_1.handleSelect)(this.prisma, table, filter);
+    }
+    update(table, filter, value) {
+        return (0, storage_handlers_1.handleUpdate)(this.prisma, table, filter, value);
+    }
+    delete(table, filter) {
+        return (0, storage_handlers_1.handleDelete)(this.prisma, table, filter);
+    }
+}
+exports.SqlDatabase = SqlDatabase;

package/dist/transformers/enum/grand-final-type.d.ts

@@ -0,0 +1,6 @@
+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";
+};

package/dist/transformers/enum/grand-final-type.js

@@ -0,0 +1,49 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrandFinalTypeTransformer = void 0;
+const Prisma = __importStar(require("@prisma/client"));
+exports.GrandFinalTypeTransformer = {
+    to(type) {
+        switch (type) {
+            case 'none':
+                return Prisma.GrandFinalType.NONE;
+            case 'simple':
+                return Prisma.GrandFinalType.SIMPLE;
+            case 'double':
+                return Prisma.GrandFinalType.DOUBLE;
+        }
+    },
+    from(type) {
+        switch (type) {
+            case Prisma.GrandFinalType.NONE:
+                return 'none';
+            case Prisma.GrandFinalType.SIMPLE:
+                return 'simple';
+            case Prisma.GrandFinalType.DOUBLE:
+                return 'double';
+        }
+    },
+};

package/dist/transformers/enum/index.d.ts

@@ -0,0 +1,6 @@
+export * from './grand-final-type';
+export * from './match-result';
+export * from './match-status';
+export * from './round-robin-mode';
+export * from './seed-ordering';
+export * from './stage-type';

package/dist/transformers/enum/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("./grand-final-type"), exports);
+__exportStar(require("./match-result"), exports);
+__exportStar(require("./match-status"), exports);
+__exportStar(require("./round-robin-mode"), exports);
+__exportStar(require("./seed-ordering"), exports);
+__exportStar(require("./stage-type"), exports);

package/dist/transformers/enum/match-result.d.ts

@@ -0,0 +1,6 @@
+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";
+};

package/dist/transformers/enum/match-result.js

@@ -0,0 +1,49 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchResultTransformer = void 0;
+const Prisma = __importStar(require("@prisma/client"));
+exports.MatchResultTransformer = {
+    to(result) {
+        switch (result) {
+            case 'win':
+                return Prisma.MatchResult.WIN;
+            case 'draw':
+                return Prisma.MatchResult.DRAW;
+            case 'loss':
+                return Prisma.MatchResult.LOSS;
+        }
+    },
+    from(result) {
+        switch (result) {
+            case Prisma.MatchResult.WIN:
+                return 'win';
+            case Prisma.MatchResult.DRAW:
+                return 'draw';
+            case Prisma.MatchResult.LOSS:
+                return 'loss';
+        }
+    },
+};

package/dist/transformers/enum/match-status.d.ts

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

package/dist/transformers/enum/match-status.js

@@ -0,0 +1,62 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchStatusTransformer = void 0;
+const Prisma = __importStar(require("@prisma/client"));
+const brackets_model_1 = require("brackets-model");
+exports.MatchStatusTransformer = {
+    to(status) {
+        switch (status) {
+            case brackets_model_1.Status.Locked:
+                return Prisma.MatchStatus.LOCKED;
+            case brackets_model_1.Status.Waiting:
+                return Prisma.MatchStatus.WAITING;
+            case brackets_model_1.Status.Ready:
+                return Prisma.MatchStatus.READY;
+            case brackets_model_1.Status.Running:
+                return Prisma.MatchStatus.RUNNING;
+            case brackets_model_1.Status.Completed:
+                return Prisma.MatchStatus.COMPLETED;
+            case brackets_model_1.Status.Archived:
+                return Prisma.MatchStatus.ARCHIVED;
+        }
+    },
+    from(status) {
+        switch (status) {
+            case Prisma.MatchStatus.LOCKED:
+                return brackets_model_1.Status.Locked;
+            case Prisma.MatchStatus.WAITING:
+                return brackets_model_1.Status.Waiting;
+            case Prisma.MatchStatus.READY:
+                return brackets_model_1.Status.Ready;
+            case Prisma.MatchStatus.RUNNING:
+                return brackets_model_1.Status.Running;
+            case Prisma.MatchStatus.COMPLETED:
+                return brackets_model_1.Status.Completed;
+            case Prisma.MatchStatus.ARCHIVED:
+                return brackets_model_1.Status.Archived;
+        }
+    },
+};

package/dist/transformers/enum/round-robin-mode.d.ts

@@ -0,0 +1,6 @@
+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";
+};

package/dist/transformers/enum/round-robin-mode.js

@@ -0,0 +1,45 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoundRobinModeTransformer = void 0;
+const Prisma = __importStar(require("@prisma/client"));
+exports.RoundRobinModeTransformer = {
+    to(mode) {
+        switch (mode) {
+            case 'simple':
+                return Prisma.RoundRobinMode.SIMPLE;
+            case 'double':
+                return Prisma.RoundRobinMode.DOUBLE;
+        }
+    },
+    from(mode) {
+        switch (mode) {
+            case Prisma.RoundRobinMode.SIMPLE:
+                return 'simple';
+            case Prisma.RoundRobinMode.DOUBLE:
+                return 'double';
+        }
+    },
+};

package/dist/transformers/enum/seed-ordering.d.ts

@@ -0,0 +1,6 @@
+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";
+};

package/dist/transformers/enum/seed-ordering.js

@@ -0,0 +1,73 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedOrderingTransformer = void 0;
+const Prisma = __importStar(require("@prisma/client"));
+exports.SeedOrderingTransformer = {
+    to(ordering) {
+        switch (ordering) {
+            case 'natural':
+                return Prisma.SeedOrdering.NATURAL;
+            case 'reverse':
+                return Prisma.SeedOrdering.REVERSE;
+            case 'half_shift':
+                return Prisma.SeedOrdering.HALF_SHIFT;
+            case 'reverse_half_shift':
+                return Prisma.SeedOrdering.REVERSE_HALF_SHIFT;
+            case 'pair_flip':
+                return Prisma.SeedOrdering.PAIR_FLIP;
+            case 'inner_outer':
+                return Prisma.SeedOrdering.INNER_OUTER;
+            case 'groups.effort_balanced':
+                return Prisma.SeedOrdering.GROUPS_EFFORT_BALANCED;
+            case 'groups.seed_optimized':
+                return Prisma.SeedOrdering.GROUPS_SEED_OPTIMIZED;
+            case 'groups.bracket_optimized':
+                return Prisma.SeedOrdering.GROUPS_BRACKET_OPTIMIZED;
+        }
+    },
+    from(ordering) {
+        switch (ordering) {
+            case Prisma.SeedOrdering.NATURAL:
+                return 'natural';
+            case Prisma.SeedOrdering.REVERSE:
+                return 'reverse';
+            case Prisma.SeedOrdering.HALF_SHIFT:
+                return 'half_shift';
+            case Prisma.SeedOrdering.REVERSE_HALF_SHIFT:
+                return 'reverse_half_shift';
+            case Prisma.SeedOrdering.PAIR_FLIP:
+                return 'pair_flip';
+            case Prisma.SeedOrdering.INNER_OUTER:
+                return 'inner_outer';
+            case Prisma.SeedOrdering.GROUPS_EFFORT_BALANCED:
+                return 'groups.effort_balanced';
+            case Prisma.SeedOrdering.GROUPS_SEED_OPTIMIZED:
+                return 'groups.seed_optimized';
+            case Prisma.SeedOrdering.GROUPS_BRACKET_OPTIMIZED:
+                return 'groups.bracket_optimized';
+        }
+    },
+};

package/dist/transformers/enum/stage-type.d.ts

@@ -0,0 +1,6 @@
+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";
+};

package/dist/transformers/enum/stage-type.js

@@ -0,0 +1,49 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageTypeTransformer = void 0;
+const Prisma = __importStar(require("@prisma/client"));
+exports.StageTypeTransformer = {
+    to(type) {
+        switch (type) {
+            case 'round_robin':
+                return Prisma.StageType.ROUND_ROBIN;
+            case 'single_elimination':
+                return Prisma.StageType.SINGLE_ELIMINATION;
+            case 'double_elimination':
+                return Prisma.StageType.DOUBLE_ELIMINATION;
+        }
+    },
+    from(type) {
+        switch (type) {
+            case Prisma.StageType.ROUND_ROBIN:
+                return 'round_robin';
+            case Prisma.StageType.SINGLE_ELIMINATION:
+                return 'single_elimination';
+            case Prisma.StageType.DOUBLE_ELIMINATION:
+                return 'double_elimination';
+        }
+    },
+};

package/dist/transformers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './enum';
+export * from './model';

package/dist/transformers/index.js

@@ -0,0 +1,18 @@
+"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("./enum"), exports);
+__exportStar(require("./model"), exports);

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

@@ -0,0 +1,17 @@
+import { Group } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+export declare const GroupTransformer: {
+    to(input: OmitId<Group>): {
+        stageId: number;
+        number: number;
+    };
+    from(output: import("@prisma/client/runtime").GetResult<{
+        id: number;
+        stageId: number;
+        number: number;
+    }, unknown> & {}): {
+        id: number;
+        stage_id: number;
+        number: number;
+    };
+};