brackets-drizzle-db 2.1.0

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoundRobinModeTransformer = void 0;
+exports.RoundRobinModeTransformer = {
+    to(mode) {
+        switch (mode) {
+            case 'simple':
+                return 'SIMPLE';
+            case 'double':
+                return 'DOUBLE';
+        }
+    },
+    from(mode) {
+        switch (mode) {
+            case 'SIMPLE':
+                return 'simple';
+            case 'DOUBLE':
+                return 'double';
+        }
+    },
+};

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

@@ -0,0 +1,6 @@
+import { SeedOrdering } from 'brackets-model';
+import type { SeedOrdering as DrizzleSeedOrdering } from '../../db/schema/enums';
+export declare const SeedOrderingTransformer: {
+    to(ordering: SeedOrdering): DrizzleSeedOrdering;
+    from(ordering: DrizzleSeedOrdering): SeedOrdering;
+};

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedOrderingTransformer = void 0;
+exports.SeedOrderingTransformer = {
+    to(ordering) {
+        switch (ordering) {
+            case 'natural':
+                return 'NATURAL';
+            case 'reverse':
+                return 'REVERSE';
+            case 'half_shift':
+                return 'HALF_SHIFT';
+            case 'reverse_half_shift':
+                return 'REVERSE_HALF_SHIFT';
+            case 'pair_flip':
+                return 'PAIR_FLIP';
+            case 'inner_outer':
+                return 'INNER_OUTER';
+            case 'groups.effort_balanced':
+                return 'GROUPS_EFFORT_BALANCED';
+            case 'groups.seed_optimized':
+                return 'GROUPS_SEED_OPTIMIZED';
+            case 'groups.bracket_optimized':
+                return 'GROUPS_BRACKET_OPTIMIZED';
+        }
+    },
+    from(ordering) {
+        switch (ordering) {
+            case 'NATURAL':
+                return 'natural';
+            case 'REVERSE':
+                return 'reverse';
+            case 'HALF_SHIFT':
+                return 'half_shift';
+            case 'REVERSE_HALF_SHIFT':
+                return 'reverse_half_shift';
+            case 'PAIR_FLIP':
+                return 'pair_flip';
+            case 'INNER_OUTER':
+                return 'inner_outer';
+            case 'GROUPS_EFFORT_BALANCED':
+                return 'groups.effort_balanced';
+            case 'GROUPS_SEED_OPTIMIZED':
+                return 'groups.seed_optimized';
+            case 'GROUPS_BRACKET_OPTIMIZED':
+                return 'groups.bracket_optimized';
+        }
+    },
+};

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

@@ -0,0 +1,6 @@
+import { StageType } from 'brackets-model';
+import type { StageType as DrizzleStageType } from '../../db/schema/enums';
+export declare const StageTypeTransformer: {
+    to(type: StageType): DrizzleStageType;
+    from(type: DrizzleStageType): StageType;
+};

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageTypeTransformer = void 0;
+exports.StageTypeTransformer = {
+    to(type) {
+        switch (type) {
+            case 'round_robin':
+                return 'ROUND_ROBIN';
+            case 'single_elimination':
+                return 'SINGLE_ELIMINATION';
+            case 'double_elimination':
+                return 'DOUBLE_ELIMINATION';
+        }
+    },
+    from(type) {
+        switch (type) {
+            case 'ROUND_ROBIN':
+                return 'round_robin';
+            case 'SINGLE_ELIMINATION':
+                return 'single_elimination';
+            case '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,15 @@
+import { Group } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+import type { Group as DrizzleGroup } from '../../db/schema';
+type GroupInput = {
+    stage_id: number | string;
+    number: number;
+};
+export declare const GroupTransformer: {
+    to(input: OmitId<Group> | GroupInput): {
+        stageId: string;
+        number: number;
+    };
+    from(output: DrizzleGroup): Group;
+};
+export {};

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: String(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,9 @@
+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';
+export * from './tournament';

package/dist/transformers/model/index.js

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

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

@@ -0,0 +1,21 @@
+import { OmitId } from 'brackets-manager';
+import type { MatchGameWithExtra, MatchGameExtrasInput, JsonValue } from '../../types';
+import type { MatchGame as DrizzleMatchGame, ParticipantMatchGameResult } from '../../db/schema';
+type DrizzleMatchGameWithRelations = DrizzleMatchGame & {
+    opponent1Result: ParticipantMatchGameResult | null;
+    opponent2Result: ParticipantMatchGameResult | null;
+};
+export declare function matchGameExtraFromInput(input: MatchGameExtrasInput, previousExtra?: JsonValue | null): JsonValue | null | undefined;
+export declare const MatchGameTransformer: {
+    to(input: Omit<OmitId<MatchGameWithExtra>, "opponent1" | "opponent2">): {
+        status: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
+        stageId: string;
+        matchId: string;
+        number: number;
+        extra: string | number | boolean | JsonValue[] | {
+            [key: string]: JsonValue;
+        } | null;
+    };
+    from(output: DrizzleMatchGameWithRelations): MatchGameWithExtra;
+};
+export {};

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchGameTransformer = void 0;
+exports.matchGameExtraFromInput = matchGameExtraFromInput;
+const __1 = require("..");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getMatchGameExtras(input) {
+    const clone = { ...input };
+    delete clone.id;
+    delete clone.status;
+    delete clone.stage_id;
+    delete clone.parent_id;
+    delete clone.number;
+    delete clone.opponent1;
+    delete clone.opponent2;
+    delete clone.extra;
+    return Object.entries(clone).reduce((extras, [key, value]) => {
+        if (value !== undefined) {
+            extras[key] = value;
+        }
+        return extras;
+    }, {});
+}
+function normalizeMatchGameExtras(extra) {
+    if (!isRecord(extra)) {
+        return {};
+    }
+    return extra;
+}
+function hasOwnExtraProperty(input) {
+    return Object.prototype.hasOwnProperty.call(input, 'extra');
+}
+function matchGameExtraFromInput(input, previousExtra) {
+    const customFields = getMatchGameExtras(input);
+    const hasCustomFields = Object.keys(customFields).length > 0;
+    if (hasOwnExtraProperty(input)) {
+        const providedExtra = input.extra;
+        if (providedExtra === undefined) {
+            return hasCustomFields ? customFields : undefined;
+        }
+        if (isRecord(providedExtra)) {
+            const normalized = providedExtra;
+            return hasCustomFields
+                ? { ...normalized, ...customFields }
+                : normalized;
+        }
+        return providedExtra ?? null;
+    }
+    if (!hasCustomFields) {
+        return undefined;
+    }
+    if (isRecord(previousExtra)) {
+        const normalized = previousExtra;
+        return { ...normalized, ...customFields };
+    }
+    return customFields;
+}
+exports.MatchGameTransformer = {
+    to(input) {
+        const extrasInput = input;
+        const extra = matchGameExtraFromInput(extrasInput);
+        return {
+            status: __1.MatchStatusTransformer.to(input.status),
+            stageId: String(input.stage_id),
+            matchId: String(input.parent_id),
+            number: input.number,
+            extra: extra ?? null,
+        };
+    },
+    from(output) {
+        const normalizedExtras = normalizeMatchGameExtras(output.extra);
+        return {
+            id: output.id,
+            status: __1.MatchStatusTransformer.from(output.status),
+            stage_id: output.stageId,
+            parent_id: output.matchId,
+            number: output.number,
+            ...normalizedExtras,
+            extra: output.extra ?? undefined,
+            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,23 @@
+import { OmitId } from 'brackets-manager';
+import type { MatchWithExtra, MatchExtrasInput, JsonValue } from '../../types';
+import type { Match as DrizzleMatch, ParticipantMatchResult } from '../../db/schema';
+type DrizzleMatchWithRelations = DrizzleMatch & {
+    opponent1Result: ParticipantMatchResult | null;
+    opponent2Result: ParticipantMatchResult | null;
+};
+export declare function matchExtraFromInput(input: MatchExtrasInput, previousExtra?: JsonValue | null): JsonValue | null | undefined;
+export declare const MatchTransformer: {
+    to(input: Omit<OmitId<MatchWithExtra>, "opponent1" | "opponent2">): {
+        status: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
+        stageId: string;
+        groupId: string;
+        roundId: string;
+        number: number;
+        childCount: number;
+        extra: string | number | boolean | JsonValue[] | {
+            [key: string]: JsonValue;
+        } | null;
+    };
+    from(output: DrizzleMatchWithRelations): MatchWithExtra;
+};
+export {};

package/dist/transformers/model/match.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchTransformer = void 0;
+exports.matchExtraFromInput = matchExtraFromInput;
+const __1 = require("..");
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function getMatchExtras(input) {
+    const clone = { ...input };
+    delete clone.id;
+    delete clone.status;
+    delete clone.stage_id;
+    delete clone.group_id;
+    delete clone.round_id;
+    delete clone.number;
+    delete clone.child_count;
+    delete clone.opponent1;
+    delete clone.opponent2;
+    delete clone.extra;
+    return Object.entries(clone).reduce((extras, [key, value]) => {
+        if (value !== undefined) {
+            extras[key] = value;
+        }
+        return extras;
+    }, {});
+}
+function normalizeMatchExtras(extra) {
+    if (!isRecord(extra)) {
+        return {};
+    }
+    return extra;
+}
+function hasOwnExtraProperty(input) {
+    return Object.prototype.hasOwnProperty.call(input, 'extra');
+}
+function matchExtraFromInput(input, previousExtra) {
+    const customFields = getMatchExtras(input);
+    const hasCustomFields = Object.keys(customFields).length > 0;
+    if (hasOwnExtraProperty(input)) {
+        const providedExtra = input.extra;
+        if (providedExtra === undefined) {
+            return hasCustomFields ? customFields : undefined;
+        }
+        if (isRecord(providedExtra)) {
+            const normalized = providedExtra;
+            return hasCustomFields
+                ? { ...normalized, ...customFields }
+                : normalized;
+        }
+        return providedExtra ?? null;
+    }
+    if (!hasCustomFields) {
+        return undefined;
+    }
+    if (isRecord(previousExtra)) {
+        const normalized = previousExtra;
+        return { ...normalized, ...customFields };
+    }
+    return customFields;
+}
+exports.MatchTransformer = {
+    to(input) {
+        const extrasInput = input;
+        const extra = matchExtraFromInput(extrasInput);
+        return {
+            status: __1.MatchStatusTransformer.to(input.status),
+            stageId: String(input.stage_id),
+            groupId: String(input.group_id),
+            roundId: String(input.round_id),
+            number: input.number,
+            childCount: input.child_count,
+            extra: extra ?? null,
+        };
+    },
+    from(output) {
+        const normalizedExtras = normalizeMatchExtras(output.extra);
+        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,
+            ...normalizedExtras,
+            extra: output.extra ?? undefined,
+            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,21 @@
+import { ParticipantResult } from 'brackets-model';
+import type { ParticipantMatchResult, ParticipantMatchGameResult } from '../../db/schema';
+type DrizzleParticipantResult = ParticipantMatchResult | ParticipantMatchGameResult;
+type ParticipantResultInput = {
+    id?: number | string | null;
+    forfeit?: boolean;
+    position?: number;
+    score?: number;
+    result?: 'win' | 'draw' | 'loss';
+};
+export declare const ParticipantMatchResultTransformer: {
+    to(input: ParticipantResultInput): {
+        participantId: string | null;
+        forfeit: boolean | null;
+        position: number | null;
+        score: number | null;
+        result: "WIN" | "DRAW" | "LOSS" | null;
+    };
+    from(output: DrizzleParticipantResult): ParticipantResult;
+};
+export {};

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantMatchResultTransformer = void 0;
+const __1 = require("..");
+exports.ParticipantMatchResultTransformer = {
+    to(input) {
+        return {
+            participantId: input.id != null ? String(input.id) : null,
+            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 ?? null,
+            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,19 @@
+import { Participant } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+import type { Participant as DrizzleParticipant } from '../../db/schema';
+import type { JsonValue } from '../../types';
+export declare function participantExtraFromInput(input: Record<string, unknown>): JsonValue | null;
+type ParticipantInput = {
+    name: string;
+    tournament_id: number | string;
+    [key: string]: unknown;
+};
+export declare const ParticipantTransformer: {
+    to(input: OmitId<Participant> | ParticipantInput): {
+        name: string;
+        tournamentId: string;
+        extra: JsonValue;
+    };
+    from(output: DrizzleParticipant): Participant;
+};
+export {};

package/dist/transformers/model/participant.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantTransformer = void 0;
+exports.participantExtraFromInput = participantExtraFromInput;
+function getParticipantExtras(input) {
+    const clone = { ...input };
+    // Delete Participant fields
+    delete clone.id;
+    delete clone.name;
+    delete clone.tournament_id;
+    delete clone.extra;
+    // Return Extras
+    return clone;
+}
+function getParticipantExtraValue(input) {
+    const extra = getParticipantExtras(input);
+    return Object.keys(extra).length > 0 ? extra : null;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeParticipantExtras(extra) {
+    if (!isRecord(extra)) {
+        return {};
+    }
+    return extra;
+}
+function participantExtraFromInput(input) {
+    return getParticipantExtraValue(input);
+}
+exports.ParticipantTransformer = {
+    to(input) {
+        return {
+            name: input.name,
+            tournamentId: String(input.tournament_id),
+            extra: getParticipantExtraValue(input),
+        };
+    },
+    from(output) {
+        return {
+            id: output.id,
+            name: output.name,
+            tournament_id: output.tournamentId,
+            ...normalizeParticipantExtras(output.extra),
+        };
+    },
+};

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

@@ -0,0 +1,17 @@
+import { Round } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+import type { Round as DrizzleRound } from '../../db/schema';
+type RoundInput = {
+    stage_id: number | string;
+    group_id: number | string;
+    number: number;
+};
+export declare const RoundTransformer: {
+    to(input: OmitId<Round> | RoundInput): {
+        stageId: string;
+        groupId: string;
+        number: number;
+    };
+    from(output: DrizzleRound): Round;
+};
+export {};

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: String(input.stage_id),
+            groupId: String(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,18 @@
+import { StageSettings } from 'brackets-model';
+import { OmitId } from 'brackets-manager';
+import type { StageSettings as DrizzleStageSettings } from '../../db/schema';
+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: number[][] | null;
+        consolationFinal: boolean | null;
+        skipFirstRound: boolean | null;
+        grandFinal: "NONE" | "SIMPLE" | "DOUBLE" | null;
+    };
+    from(output: Omit<DrizzleStageSettings, "stageId">): StageSettings;
+};

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

@@ -0,0 +1,46 @@
+"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: input.manualOrdering ?? null,
+            consolationFinal: input.consolationFinal ?? null,
+            skipFirstRound: input.skipFirstRound ?? null,
+            grandFinal: input.grandFinal
+                ? __1.GrandFinalTypeTransformer.to(input.grandFinal)
+                : null,
+        };
+    },
+    from(output) {
+        return {
+            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,
+            consolationFinal: output.consolationFinal ?? undefined,
+            skipFirstRound: output.skipFirstRound ?? undefined,
+            grandFinal: output.grandFinal
+                ? __1.GrandFinalTypeTransformer.from(output.grandFinal)
+                : undefined,
+        };
+    },
+};