brackets-prisma-db 1.0.0

package/dist/transformers/model/group.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupTransformer = void 0;
+exports.GroupTransformer = {
+    to(input) {
+        return {
+            stageId: input.stage_id,
+            number: input.number,
+        };
+    },
+    from(output) {
+        return {
+            id: output.id,
+            stage_id: output.stageId,
+            number: output.number,
+        };
+    },
+};

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

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

package/dist/transformers/model/index.js

@@ -0,0 +1,24 @@
+"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("./participant-result"), exports);
+__exportStar(require("./round"), exports);
+__exportStar(require("./stage"), exports);
+__exportStar(require("./stage-settings"), exports);

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

@@ -0,0 +1,41 @@
+import * as Prisma from '@prisma/client';
+import { MatchGame } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+export declare const MatchGameTransformer: {
+    to(input: Omit<OmitId<MatchGame>, "opponent1" | "opponent2">): {
+        status: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
+        stageId: number;
+        matchId: number;
+        number: number;
+    };
+    from(output: import("@prisma/client/runtime").GetResult<{
+        id: number;
+        status: Prisma.MatchStatus;
+        stageId: number;
+        matchId: number;
+        number: number;
+    }, unknown> & {} & {
+        opponent1Result: Prisma.ParticipantMatchGameResult | null;
+        opponent2Result: Prisma.ParticipantMatchGameResult | null;
+    }): {
+        id: number;
+        status: import("brackets-model").Status;
+        stage_id: number;
+        parent_id: number;
+        number: number;
+        opponent1: {
+            id: number | null;
+            forfeit: boolean | undefined;
+            position: number | undefined;
+            score: number | undefined;
+            result: "win" | "draw" | "loss" | undefined;
+        } | null;
+        opponent2: {
+            id: number | null;
+            forfeit: boolean | undefined;
+            position: number | undefined;
+            score: number | undefined;
+            result: "win" | "draw" | "loss" | undefined;
+        } | null;
+    };
+};

package/dist/transformers/model/match-game.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchGameTransformer = void 0;
+const __1 = require("..");
+exports.MatchGameTransformer = {
+    to(input) {
+        return {
+            status: __1.MatchStatusTransformer.to(input.status),
+            stageId: input.stage_id,
+            matchId: input.parent_id,
+            number: input.number,
+        };
+    },
+    from(output) {
+        return {
+            id: output.id,
+            status: __1.MatchStatusTransformer.from(output.status),
+            stage_id: output.stageId,
+            parent_id: output.matchId,
+            number: output.number,
+            opponent1: output.opponent1Result
+                ? __1.ParticipantMatchResultTransformer.from(output.opponent1Result)
+                : null,
+            opponent2: output.opponent2Result
+                ? __1.ParticipantMatchResultTransformer.from(output.opponent2Result)
+                : null,
+        };
+    },
+};

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

@@ -0,0 +1,47 @@
+import * as Prisma from '@prisma/client';
+import { Match } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+export declare const MatchTransformer: {
+    to(input: Omit<OmitId<Match>, "opponent1" | "opponent2">): {
+        status: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
+        stageId: number;
+        groupId: number;
+        roundId: number;
+        number: number;
+        childCount: number;
+    };
+    from(output: import("@prisma/client/runtime").GetResult<{
+        id: number;
+        status: Prisma.MatchStatus;
+        stageId: number;
+        groupId: number;
+        roundId: number;
+        number: number;
+        childCount: number;
+    }, unknown> & {} & {
+        opponent1Result: Prisma.ParticipantMatchResult | null;
+        opponent2Result: Prisma.ParticipantMatchResult | null;
+    }): {
+        id: number;
+        status: import("brackets-model").Status;
+        stage_id: number;
+        group_id: number;
+        round_id: number;
+        number: number;
+        child_count: number;
+        opponent1: {
+            id: number | null;
+            forfeit: boolean | undefined;
+            position: number | undefined;
+            score: number | undefined;
+            result: "win" | "draw" | "loss" | undefined;
+        } | null;
+        opponent2: {
+            id: number | null;
+            forfeit: boolean | undefined;
+            position: number | undefined;
+            score: number | undefined;
+            result: "win" | "draw" | "loss" | undefined;
+        } | null;
+    };
+};

package/dist/transformers/model/match.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchTransformer = void 0;
+const __1 = require("..");
+exports.MatchTransformer = {
+    to(input) {
+        return {
+            status: __1.MatchStatusTransformer.to(input.status),
+            stageId: input.stage_id,
+            groupId: input.group_id,
+            roundId: input.round_id,
+            number: input.number,
+            childCount: input.child_count,
+        };
+    },
+    from(output) {
+        return {
+            id: output.id,
+            status: __1.MatchStatusTransformer.from(output.status),
+            stage_id: output.stageId,
+            group_id: output.groupId,
+            round_id: output.roundId,
+            number: output.number,
+            child_count: output.childCount,
+            opponent1: output.opponent1Result
+                ? __1.ParticipantMatchResultTransformer.from(output.opponent1Result)
+                : null,
+            opponent2: output.opponent2Result
+                ? __1.ParticipantMatchResultTransformer.from(output.opponent2Result)
+                : null,
+        };
+    },
+};

package/dist/transformers/model/participant-result.d.ts

@@ -0,0 +1,36 @@
+import * as Prisma from '@prisma/client';
+import { ParticipantResult } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+export declare const ParticipantMatchResultTransformer: {
+    to(input: OmitId<ParticipantResult>): {
+        forfeit: boolean | null;
+        position: number | null;
+        score: number | null;
+        result: "WIN" | "DRAW" | "LOSS" | null;
+    };
+    from(output: (import("@prisma/client/runtime").GetResult<{
+        id: number;
+        participantId: number | null;
+        position: number | null;
+        forfeit: boolean | null;
+        score: number | null;
+        result: Prisma.MatchResult | null;
+        opponent1MatchId: number | null;
+        opponent2MatchId: number | null;
+    }, unknown> & {}) | (import("@prisma/client/runtime").GetResult<{
+        id: number;
+        participantId: number | null;
+        position: number | null;
+        forfeit: boolean | null;
+        score: number | null;
+        result: Prisma.MatchResult | null;
+        opponent1MatchGameId: number | null;
+        opponent2MatchGameId: number | null;
+    }, unknown> & {})): {
+        id: number | null;
+        forfeit: boolean | undefined;
+        position: number | undefined;
+        score: number | undefined;
+        result: "win" | "draw" | "loss" | undefined;
+    };
+};

package/dist/transformers/model/participant-result.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantMatchResultTransformer = void 0;
+const __1 = require("..");
+exports.ParticipantMatchResultTransformer = {
+    to(input) {
+        return {
+            forfeit: input.forfeit ?? null,
+            position: input.position ?? null,
+            score: input.score ?? null,
+            result: input.result
+                ? __1.MatchResultTransformer.to(input.result)
+                : null,
+        };
+    },
+    from(output) {
+        return {
+            id: output.participantId,
+            forfeit: output.forfeit ?? undefined,
+            position: output.position ?? undefined,
+            score: output.score ?? undefined,
+            result: output.result
+                ? __1.MatchResultTransformer.from(output.result)
+                : undefined,
+        };
+    },
+};

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

@@ -0,0 +1,17 @@
+import { Participant } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+export declare const ParticipantTransformer: {
+    to(input: OmitId<Participant>): {
+        name: string;
+        tournamentId: number;
+    };
+    from(output: import("@prisma/client/runtime").GetResult<{
+        id: number;
+        tournamentId: number;
+        name: string;
+    }, unknown> & {}): {
+        id: number;
+        name: string;
+        tournament_id: number;
+    };
+};

package/dist/transformers/model/participant.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantTransformer = void 0;
+function getParticipantExtras(input) {
+    const clone = { ...input };
+    // Delete Participant fields
+    delete clone.id;
+    delete clone.name;
+    delete clone.tournament_id;
+    // Return Extras
+    return clone;
+}
+exports.ParticipantTransformer = {
+    to(input) {
+        return {
+            name: input.name,
+            tournamentId: input.tournament_id,
+            ...getParticipantExtras(input),
+        };
+    },
+    from(output) {
+        return {
+            id: output.id,
+            name: output.name,
+            tournament_id: output.tournamentId,
+        };
+    },
+};

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

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

package/dist/transformers/model/round.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoundTransformer = void 0;
+exports.RoundTransformer = {
+    to(input) {
+        return {
+            stageId: input.stage_id,
+            groupId: input.group_id,
+            number: input.number,
+        };
+    },
+    from(output) {
+        return {
+            id: output.id,
+            stage_id: output.stageId,
+            group_id: output.groupId,
+            number: output.number,
+        };
+    },
+};

package/dist/transformers/model/stage-settings.d.ts

@@ -0,0 +1,43 @@
+import * as Prisma from '@prisma/client';
+import { StageSettings } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+export declare const StageSettingsTransformer: {
+    to(input: OmitId<StageSettings>): {
+        size: number | null;
+        seedOrdering: ("NATURAL" | "REVERSE" | "HALF_SHIFT" | "REVERSE_HALF_SHIFT" | "PAIR_FLIP" | "INNER_OUTER" | "GROUPS_EFFORT_BALANCED" | "GROUPS_SEED_OPTIMIZED" | "GROUPS_BRACKET_OPTIMIZED")[];
+        balanceByes: boolean | null;
+        matchesChildCount: number | null;
+        groupCount: number | null;
+        roundRobinMode: "SIMPLE" | "DOUBLE" | null;
+        manualOrdering: string;
+        consolationFinal: boolean | null;
+        skipFirstRound: boolean | null;
+        grandFinal: "SIMPLE" | "DOUBLE" | "NONE" | null;
+    };
+    from(output: Omit<import("@prisma/client/runtime").GetResult<{
+        id: string;
+        stageId: number;
+        size: number | null;
+        seedOrdering: Prisma.SeedOrdering[];
+        balanceByes: boolean | null;
+        matchesChildCount: number | null;
+        groupCount: number | null;
+        roundRobinMode: Prisma.RoundRobinMode | null;
+        manualOrdering: Prisma.Prisma.JsonValue;
+        consolationFinal: boolean | null;
+        skipFirstRound: boolean | null;
+        grandFinal: Prisma.GrandFinalType | null;
+    }, unknown> & {}, "stageId">): {
+        id: string;
+        size: number | undefined;
+        seedOrdering: ("reverse" | "natural" | "half_shift" | "reverse_half_shift" | "pair_flip" | "inner_outer" | "groups.effort_balanced" | "groups.seed_optimized" | "groups.bracket_optimized")[];
+        balanceByes: boolean | undefined;
+        matchesChildCount: number | undefined;
+        groupCount: number | undefined;
+        roundRobinMode: "simple" | "double" | undefined;
+        manualOrdering: any;
+        consolationFinal: boolean | undefined;
+        skipFirstRound: boolean | undefined;
+        grandFinal: "none" | "simple" | "double" | undefined;
+    };
+};

package/dist/transformers/model/stage-settings.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageSettingsTransformer = void 0;
+const __1 = require("..");
+exports.StageSettingsTransformer = {
+    to(input) {
+        return {
+            size: input.size ?? null,
+            seedOrdering: input.seedOrdering
+                ? input.seedOrdering.map(__1.SeedOrderingTransformer.to)
+                : [],
+            balanceByes: input.balanceByes ?? null,
+            matchesChildCount: input.matchesChildCount ?? null,
+            groupCount: input.groupCount ?? null,
+            roundRobinMode: input.roundRobinMode
+                ? __1.RoundRobinModeTransformer.to(input.roundRobinMode)
+                : null,
+            manualOrdering: JSON.stringify(input.manualOrdering),
+            consolationFinal: input.consolationFinal ?? null,
+            skipFirstRound: input.skipFirstRound ?? null,
+            grandFinal: input.grandFinal
+                ? __1.GrandFinalTypeTransformer.to(input.grandFinal)
+                : null,
+        };
+    },
+    from(output) {
+        return {
+            id: output.id,
+            size: output.size ?? undefined,
+            seedOrdering: output.seedOrdering
+                ? output.seedOrdering.map(__1.SeedOrderingTransformer.from)
+                : [],
+            balanceByes: output.balanceByes ?? undefined,
+            matchesChildCount: output.matchesChildCount ?? undefined,
+            groupCount: output.groupCount ?? undefined,
+            roundRobinMode: output.roundRobinMode
+                ? __1.RoundRobinModeTransformer.from(output.roundRobinMode)
+                : undefined,
+            manualOrdering: output.manualOrdering
+                ? JSON.parse(output.manualOrdering?.toString())
+                : undefined,
+            consolationFinal: output.consolationFinal ?? undefined,
+            skipFirstRound: output.skipFirstRound ?? undefined,
+            grandFinal: output.grandFinal
+                ? __1.GrandFinalTypeTransformer.from(output.grandFinal)
+                : undefined,
+        };
+    },
+};

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

@@ -0,0 +1,39 @@
+import * as Prisma from '@prisma/client';
+import { Stage } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+export declare const StageTransformer: {
+    to(input: Omit<OmitId<Stage>, "settings">): {
+        name: string;
+        tournamentId: number;
+        number: number;
+        type: "ROUND_ROBIN" | "SINGLE_ELIMINATION" | "DOUBLE_ELIMINATION";
+    };
+    from(output: import("@prisma/client/runtime").GetResult<{
+        id: number;
+        tournamentId: number;
+        name: string;
+        type: Prisma.StageType;
+        number: number;
+    }, unknown> & {} & {
+        settings: Prisma.StageSettings;
+    }): {
+        id: number;
+        name: string;
+        tournament_id: number;
+        number: number;
+        type: "round_robin" | "single_elimination" | "double_elimination";
+        settings: {
+            id: string;
+            size: number | undefined;
+            seedOrdering: ("reverse" | "natural" | "half_shift" | "reverse_half_shift" | "pair_flip" | "inner_outer" | "groups.effort_balanced" | "groups.seed_optimized" | "groups.bracket_optimized")[];
+            balanceByes: boolean | undefined;
+            matchesChildCount: number | undefined;
+            groupCount: number | undefined;
+            roundRobinMode: "simple" | "double" | undefined;
+            manualOrdering: any;
+            consolationFinal: boolean | undefined;
+            skipFirstRound: boolean | undefined;
+            grandFinal: "none" | "simple" | "double" | undefined;
+        };
+    };
+};

package/dist/transformers/model/stage.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageTransformer = void 0;
+const __1 = require("..");
+exports.StageTransformer = {
+    to(input) {
+        return {
+            name: input.name,
+            tournamentId: input.tournament_id,
+            number: input.number,
+            type: __1.StageTypeTransformer.to(input.type),
+        };
+    },
+    from(output) {
+        return {
+            id: output.id,
+            name: output.name,
+            tournament_id: output.tournamentId,
+            number: output.number,
+            type: __1.StageTypeTransformer.from(output.type),
+            settings: __1.StageSettingsTransformer.from(output.settings),
+        };
+    },
+};

package/dist/transformers/transformer.d.ts

@@ -0,0 +1,4 @@
+export type Transformer<ToInput, ToOutput, FromInput = ToOutput, FromOutput = ToInput> = {
+    to(input: ToInput): ToOutput;
+    from(output: FromInput): FromOutput;
+};

package/dist/transformers/transformer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "brackets-prisma-db",
+    "version": "1.0.0",
+    "description": "A sql database with prisma for brackets-manager.js",
+    "author": "Tandashi",
+    "license": "ISC",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Drarig29/brackets-storage.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Drarig29/brackets-storage/issues"
+    },
+    "homepage": "https://github.com/Drarig29/brackets-storage#readme",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "keywords": [
+        "types",
+        "model",
+        "brackets",
+        "tournament",
+        "manager",
+        "storage",
+        "prisma",
+        "sql"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "prepare": "npm run build",
+        "prepublishOnly": "npm run build"
+    },
+    "dependencies": {
+        "@prisma/client": "^4.16.1",
+        "brackets-manager": "^1.5.8",
+        "brackets-model": "^1.4.0",
+        "typescript": "^5.1.3"
+    },
+    "devDependencies": {
+        "@types/node": "^20.3.0",
+        "prisma": "^4.16.1"
+    },
+    "peerDependencies": {
+        "brackets-manager": "^1.3.9"
+    }
+}