volleyballsimtypes 0.0.217 → 0.0.358

package/dist/esm/src/logger.js

@@ -0,0 +1,21 @@
+import pino from 'pino';
+const isProd = process.env.NODE_ENV === 'production';
+function buildTransport() {
+    if (isProd)
+        return undefined;
+    try {
+        return pino.transport({
+            target: 'pino-pretty',
+            options: {
+                colorize: false,
+                translateTime: 'SYS:standard',
+                ignore: 'pid,hostname'
+            }
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+const logger = pino({ level: process.env.LOG_LEVEL ?? 'info' }, buildTransport());
+export default logger;

package/dist/esm/src/service/competition/division.d.ts

@@ -1,22 +1,22 @@
-import { Season } from './season';
-import { Team } from '../team';
-interface DivisionOpts {
-    readonly id: string;
-    readonly name: string;
-    readonly tier: number;
-    readonly subdivision: number;
-    readonly leagueId: string;
-    readonly seasons: Season[];
-    readonly teams?: Team[];
-}
-export declare class Division {
-    readonly id: string;
-    readonly name: string;
-    readonly tier: number;
-    readonly subdivision: number;
-    readonly leagueId: string;
-    readonly seasons: Season[];
-    readonly teams?: Team[];
-    constructor({ id, name, tier, subdivision, seasons, teams, leagueId }: DivisionOpts);
-}
-export {};
+import { Season } from './season';
+import { Team } from '../team';
+import { Country } from '../country';
+import { Iteration } from './iteration';
+interface LeagueDivisionContext {
+    readonly id: string;
+    readonly name: string;
+    readonly country: Country;
+    readonly divisions: Division[];
+}
+export declare class Division {
+    readonly id: string;
+    readonly tier: number;
+    readonly subdivision: number;
+    readonly leagueId: string;
+    readonly seasons: Season[];
+    readonly teams?: Team[];
+    static create(input: unknown): Division;
+    private constructor();
+    static createDivisions(league: LeagueDivisionContext, iterations: Iteration[]): Division[];
+}
+export {};

package/dist/esm/src/service/competition/division.js

@@ -1,11 +1,47 @@
-export class Division {
-    constructor({ id, name, tier, subdivision, seasons, teams, leagueId }) {
-        this.id = id;
-        this.name = name;
-        this.tier = tier;
-        this.subdivision = subdivision;
-        this.leagueId = leagueId;
-        this.seasons = seasons;
-        this.teams = teams;
-    }
-}
+import { Season } from './season';
+import { v4 as uuidv4 } from 'uuid';
+import { TeamGenerator } from '../team/team-generator';
+import logger from '../../logger';
+import { DivisionInputSchema } from './schemas/division.z';
+export class Division {
+    static create(input) {
+        const result = DivisionInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_DIVISION: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Division(result.data);
+    }
+    constructor({ id, tier, subdivision, seasons, teams, leagueId }) {
+        this.id = id;
+        this.tier = tier;
+        this.subdivision = subdivision;
+        this.leagueId = leagueId;
+        this.seasons = seasons;
+        this.teams = teams;
+    }
+    static createDivisions(league, iterations) {
+        const highestTier = league.divisions.reduce((max, division) => Math.max(max, division.tier), 0);
+        const divisionsToCreate = Math.pow(2, highestTier);
+        logger.info(`Creating Divisions for League: ${league.name}`);
+        return Array.from({ length: divisionsToCreate }, (_, index) => {
+            const tier = highestTier + 1;
+            const subdivision = index + 1;
+            const id = uuidv4();
+            const teams = TeamGenerator.createTeams(id, league.country);
+            const seasons = Array.from({ length: iterations.length }, (_, i) => Season.createSeason(iterations[i], teams, id));
+            return Division.create({
+                leagueId: league.id,
+                id,
+                tier,
+                subdivision,
+                seasons,
+                teams
+            });
+        });
+    }
+}

package/dist/esm/src/service/competition/index.d.ts

@@ -1,12 +1,11 @@
-export * from './standing';
-export * from './season';
-export * from './league';
-export * from './division';
-export * from './iteration';
-export * from './tournament';
-export * from './tournament-match';
-export * from './stage';
-export declare enum _CompetitionType {
-    TOURNAMENT = "TOURNAMENT",
-    LEAGUE = "LEAGUE"
-}
+export * from './standing';
+export * from './season';
+export * from './league';
+export * from './division';
+export * from './iteration';
+export * from './tournament';
+export * from './tournament-match';
+export * from './promotion-match';
+export * from './stage';
+export * from './qualifier-match';
+export * from './qualifier';

package/dist/esm/src/service/competition/index.js

@@ -1,13 +1,11 @@
-export * from './standing';
-export * from './season';
-export * from './league';
-export * from './division';
-export * from './iteration';
-export * from './tournament';
-export * from './tournament-match';
-export * from './stage';
-export var _CompetitionType;
-(function (_CompetitionType) {
-    _CompetitionType["TOURNAMENT"] = "TOURNAMENT";
-    _CompetitionType["LEAGUE"] = "LEAGUE";
-})(_CompetitionType || (_CompetitionType = {}));
+export * from './standing';
+export * from './season';
+export * from './league';
+export * from './division';
+export * from './iteration';
+export * from './tournament';
+export * from './tournament-match';
+export * from './promotion-match';
+export * from './stage';
+export * from './qualifier-match';
+export * from './qualifier';

package/dist/esm/src/service/competition/iteration.d.ts

@@ -1,10 +1,6 @@
-interface IterationOpts {
-    readonly id: number;
-    readonly startDate: Date;
-}
-export declare class Iteration {
-    readonly id: number;
-    readonly startDate: Date;
-    constructor({ id, startDate }: IterationOpts);
-}
-export {};
+export declare class Iteration {
+    readonly id: number;
+    readonly startDate: Date;
+    static create(input: unknown): Iteration;
+    private constructor();
+}

package/dist/esm/src/service/competition/iteration.js

@@ -1,8 +1,19 @@
-export class Iteration {
-    constructor({ id, startDate }) {
-        if (id < 1)
-            throw new Error(`INVALID_ITERATION: ${id}`);
-        this.id = id;
-        this.startDate = startDate;
-    }
-}
+import { IterationInputSchema } from './schemas/iteration.z';
+export class Iteration {
+    static create(input) {
+        const result = IterationInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_ITERATION: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Iteration(result.data);
+    }
+    constructor({ id, startDate }) {
+        this.id = id;
+        this.startDate = startDate;
+    }
+}

package/dist/esm/src/service/competition/league.d.ts

@@ -1,16 +1,12 @@
-import { Country } from '../country';
-import { Division } from './division';
-interface LeagueOpts {
-    readonly id: string;
-    readonly name: string;
-    readonly country: Country;
-    readonly divisions: Division[];
-}
-export declare class League {
-    readonly id: string;
-    readonly name: string;
-    readonly divisions: Division[];
-    readonly country: Country;
-    constructor({ id, name, country, divisions }: LeagueOpts);
-}
-export {};
+import { Country } from '../country';
+import { Division } from './division';
+import { Iteration } from './iteration';
+export declare class League {
+    readonly id: string;
+    readonly name: string;
+    readonly divisions: Division[];
+    readonly country: Country;
+    static create(input: unknown): League;
+    private constructor();
+    static createLeagues(countries: Country[], iterations: Iteration[], divCount: number): League[];
+}

package/dist/esm/src/service/competition/league.js

@@ -1,8 +1,42 @@
-export class League {
-    constructor({ id, name, country, divisions }) {
-        this.id = id;
-        this.name = name;
-        this.country = country;
-        this.divisions = divisions;
-    }
-}
+import { Division } from './division';
+import { v4 as uuidv4 } from 'uuid';
+import logger from '../../logger';
+import { LeagueInputSchema } from './schemas/league.z';
+export class League {
+    static create(input) {
+        const result = LeagueInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_LEAGUE: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new League(result.data);
+    }
+    constructor({ id, name, country, divisions }) {
+        this.id = id;
+        this.name = name;
+        this.country = country;
+        this.divisions = divisions;
+    }
+    static createLeagues(countries, iterations, divCount) {
+        const leagues = [];
+        logger.info('Creating Leagues');
+        for (const country of countries) {
+            const league = League.create({
+                id: uuidv4(),
+                name: `${country.name} League`,
+                country,
+                divisions: []
+            });
+            for (let i = 0; i < divCount; i++) {
+                league.divisions.push(...Division.createDivisions(league, iterations));
+            }
+            logger.info(`Created League: ${league.name}`);
+            leagues.push(league);
+        }
+        return leagues;
+    }
+}

package/dist/esm/src/service/competition/promotion-match.d.ts

@@ -0,0 +1,9 @@
+import { Match } from '../match';
+export declare class PromotionMatch {
+    readonly upperCompetitionId: string;
+    readonly lowerCompetitionId: string;
+    readonly iteration: number;
+    readonly match: Match;
+    static create(input: unknown): PromotionMatch;
+    private constructor();
+}

package/dist/esm/src/service/competition/promotion-match.js

@@ -0,0 +1,25 @@
+import { PromotionMatchInputSchema } from './schemas/promotion-match.z';
+export class PromotionMatch {
+    static create(input) {
+        const result = PromotionMatchInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_PROMOTION_MATCH: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new PromotionMatch(result.data);
+    }
+    constructor({ upperCompetitionId, lowerCompetitionId, iteration, match }) {
+        if (upperCompetitionId === lowerCompetitionId)
+            throw new Error('PROMOTION_MATCH_COMPETITION_IDS_CANNOT_BE_EQUAL');
+        if (iteration < 1)
+            throw new Error(`INVALID_ITERATION: ${iteration}`);
+        this.upperCompetitionId = upperCompetitionId;
+        this.lowerCompetitionId = lowerCompetitionId;
+        this.iteration = iteration;
+        this.match = match;
+    }
+}

package/dist/esm/src/service/competition/qualifier-match.d.ts

@@ -0,0 +1,9 @@
+import { Match } from '../match';
+import { Stage } from './stage';
+export declare class QualifierMatch {
+    readonly stage: Stage;
+    readonly match: Match;
+    readonly index: number;
+    static create(input: unknown): QualifierMatch;
+    private constructor();
+}

package/dist/esm/src/service/competition/qualifier-match.js

@@ -0,0 +1,23 @@
+import { Stage } from './stage';
+import { QualifierMatchInputSchema } from './schemas/qualifier-match.z';
+export class QualifierMatch {
+    static create(input) {
+        const result = QualifierMatchInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_QUALIFIER_MATCH: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new QualifierMatch(result.data);
+    }
+    constructor({ stage, match, index }) {
+        if (Stage.LEAGUE === stage)
+            throw new Error(`INVALID_STAGE: ${stage}`);
+        this.stage = stage;
+        this.match = match;
+        this.index = index;
+    }
+}

package/dist/esm/src/service/competition/qualifier.d.ts

@@ -0,0 +1,18 @@
+import { Team } from '../team';
+import { Iteration } from './iteration';
+import { StatusEnum } from '../../data';
+import { QualifierMatch } from './qualifier-match';
+import { Region } from '../country';
+export declare class Qualifier {
+    readonly id: string;
+    readonly iteration: Iteration;
+    readonly matches: QualifierMatch[];
+    readonly teams: Team[];
+    readonly status: StatusEnum;
+    readonly podium: Team[];
+    readonly region: Region;
+    champion?: Team;
+    static create(input: unknown): Qualifier;
+    private constructor();
+    static sortMatchesFn(m1: QualifierMatch, m2: QualifierMatch): number;
+}

package/dist/esm/src/service/competition/qualifier.js

@@ -0,0 +1,45 @@
+import { Stage } from './stage';
+import { QualifierInputSchema } from './schemas/qualifier.z';
+export class Qualifier {
+    static create(input) {
+        const result = QualifierInputSchema.safeParse(input);
+        if (!result.success) {
+            throw new Error(`INVALID_QUALIFIER: ${result.error.message}. RECEIVED=${(() => { try {
+                return JSON.stringify(input);
+            }
+            catch {
+                return String(input);
+            } })()}`);
+        }
+        return new Qualifier(result.data);
+    }
+    constructor({ id, iteration, matches, teams, status, region, champion }) {
+        this.id = id;
+        this.iteration = iteration;
+        this.matches = matches;
+        this.teams = teams;
+        this.podium = [];
+        this.status = status;
+        this.region = region;
+        this.champion = champion;
+        this.matches.sort(Qualifier.sortMatchesFn);
+        const final = this.matches.find(m => m.stage === Stage.FINAL);
+        const thirdPlace = this.matches.find(m => m.stage === Stage.THIRD_PLACE);
+        if (final == null || thirdPlace == null)
+            return;
+        this.podium = [
+            final.match.getWinner(),
+            final.match.getWinner().id === final.match.homeTeam.id ? final.match.awayTeam : final.match.homeTeam,
+            thirdPlace.match.getWinner(),
+            thirdPlace.match.getWinner().id === thirdPlace.match.homeTeam.id ? thirdPlace.match.awayTeam : thirdPlace.match.homeTeam
+        ];
+    }
+    static sortMatchesFn(m1, m2) {
+        if (m1.stage > m2.stage)
+            return -1;
+        else if (m1.stage < m2.stage)
+            return 1;
+        else
+            return m1.index - m2.index;
+    }
+}

package/dist/esm/src/service/competition/schemas/division.z.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Season } from '../season';
+export declare const DivisionInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    tier: z.ZodNumber;
+    subdivision: z.ZodNumber;
+    leagueId: z.ZodUUID;
+    seasons: z.ZodArray<z.ZodCustom<Season, Season>>;
+    teams: z.ZodOptional<z.ZodArray<z.ZodCustom<Team, Team>>>;
+}, z.core.$strip>;
+export type DivisionInput = z.infer<typeof DivisionInputSchema>;

package/dist/esm/src/service/competition/schemas/division.z.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Season } from '../season';
+const teamSchema = z.custom((v) => v instanceof Team, { message: 'INVALID_TEAM_INSTANCE' });
+const seasonSchema = z.custom((v) => v instanceof Season, { message: 'INVALID_SEASON_INSTANCE' });
+export const DivisionInputSchema = z.object({
+    id: z.uuid(),
+    tier: z.number().int().min(1),
+    subdivision: z.number().int().min(1),
+    leagueId: z.uuid(),
+    seasons: z.array(seasonSchema),
+    teams: z.array(teamSchema).optional()
+}).superRefine((data, ctx) => {
+    const maxSubdivision = Math.pow(2, data.tier - 1);
+    if (data.subdivision > maxSubdivision) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `DIVISION_SUBDIVISION_OUT_OF_RANGE_MAX_${maxSubdivision}`,
+            path: ['subdivision']
+        });
+    }
+    if (data.teams != null) {
+        const ids = data.teams.map(t => t.id);
+        if (new Set(ids).size !== ids.length) {
+            ctx.addIssue({
+                code: 'custom',
+                message: 'DIVISION_TEAMS_CONTAINS_DUPLICATES',
+                path: ['teams']
+            });
+        }
+    }
+});

package/dist/esm/src/service/competition/schemas/iteration.z.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const IterationInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    startDate: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+export type IterationInput = z.infer<typeof IterationInputSchema>;

package/dist/esm/src/service/competition/schemas/iteration.z.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export const IterationInputSchema = z.object({
+    id: z.number().int().min(1),
+    startDate: z.coerce.date()
+});

package/dist/esm/src/service/competition/schemas/league.z.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { Country } from '../../country';
+export declare const LeagueInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    name: z.ZodString;
+    country: z.ZodCustom<Country, Country>;
+    divisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        tier: z.ZodNumber;
+        subdivision: z.ZodNumber;
+        leagueId: z.ZodUUID;
+        seasons: z.ZodArray<z.ZodUnknown>;
+        teams: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type LeagueInput = z.infer<typeof LeagueInputSchema>;

package/dist/esm/src/service/competition/schemas/league.z.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { Country } from '../../country';
+const countrySchema = z.custom((v) => v instanceof Country, { message: 'INVALID_COUNTRY_INSTANCE' });
+const divisionSchema = z.object({
+    id: z.uuid(),
+    tier: z.number().int().min(1),
+    subdivision: z.number().int().min(1),
+    leagueId: z.uuid(),
+    seasons: z.array(z.unknown()),
+    teams: z.array(z.unknown()).optional()
+});
+export const LeagueInputSchema = z.object({
+    id: z.uuid(),
+    name: z.string().trim().min(1),
+    country: countrySchema,
+    divisions: z.array(divisionSchema)
+});

package/dist/esm/src/service/competition/schemas/promotion-match.z.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+export declare const PromotionMatchInputSchema: z.ZodObject<{
+    upperCompetitionId: z.ZodUUID;
+    lowerCompetitionId: z.ZodUUID;
+    iteration: z.ZodNumber;
+    match: z.ZodCustom<Match, Match>;
+}, z.core.$strip>;
+export type PromotionMatchInput = z.infer<typeof PromotionMatchInputSchema>;

package/dist/esm/src/service/competition/schemas/promotion-match.z.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+const matchSchema = z.custom((v) => v instanceof Match, { message: 'INVALID_MATCH_INSTANCE' });
+export const PromotionMatchInputSchema = z.object({
+    upperCompetitionId: z.uuid(),
+    lowerCompetitionId: z.uuid(),
+    iteration: z.number().int().min(1),
+    match: matchSchema
+}).superRefine((data, ctx) => {
+    if (data.upperCompetitionId === data.lowerCompetitionId) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'PROMOTION_MATCH_COMPETITION_IDS_CANNOT_BE_EQUAL',
+            path: ['lowerCompetitionId']
+        });
+    }
+});

package/dist/esm/src/service/competition/schemas/qualifier-match.z.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+import { Stage } from '../stage';
+export declare const QualifierMatchInputSchema: z.ZodObject<{
+    stage: z.ZodCustom<Stage, Stage>;
+    match: z.ZodCustom<Match, Match>;
+    index: z.ZodNumber;
+}, z.core.$strip>;
+export type QualifierMatchInput = z.infer<typeof QualifierMatchInputSchema>;

package/dist/esm/src/service/competition/schemas/qualifier-match.z.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { Match } from '../../match';
+import { Stage } from '../stage';
+const matchSchema = z.custom((v) => v instanceof Match, { message: 'INVALID_MATCH_INSTANCE' });
+export const QualifierMatchInputSchema = z.object({
+    stage: z.custom((v) => typeof v === 'number', { message: 'INVALID_STAGE' }),
+    match: matchSchema,
+    index: z.number().int().min(0)
+}).superRefine((data, ctx) => {
+    if (Stage.LEAGUE === data.stage) {
+        ctx.addIssue({
+            code: 'custom',
+            message: `INVALID_STAGE: ${data.stage}`,
+            path: ['stage']
+        });
+    }
+});

package/dist/esm/src/service/competition/schemas/qualifier.z.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Iteration } from '../iteration';
+import { StatusEnum } from '../../../data/common';
+import { QualifierMatch } from '../qualifier-match';
+import { Region } from '../../country';
+export declare const QualifierInputSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    iteration: z.ZodCustom<Iteration, Iteration>;
+    matches: z.ZodArray<z.ZodCustom<QualifierMatch, QualifierMatch>>;
+    teams: z.ZodArray<z.ZodCustom<Team, Team>>;
+    status: z.ZodEnum<{
+        PENDING: StatusEnum.PENDING;
+        IN_PROGRESS: StatusEnum.IN_PROGRESS;
+        COMPLETE: StatusEnum.COMPLETE;
+    }>;
+    region: z.ZodCustom<Region, Region>;
+    champion: z.ZodOptional<z.ZodCustom<Team, Team>>;
+}, z.core.$strip>;
+export type QualifierInput = z.infer<typeof QualifierInputSchema>;

package/dist/esm/src/service/competition/schemas/qualifier.z.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { Team } from '../../team';
+import { Iteration } from '../iteration';
+import { StatusEnum } from '../../../data/common';
+import { QualifierMatch } from '../qualifier-match';
+const teamSchema = z.custom((v) => v instanceof Team, { message: 'INVALID_TEAM_INSTANCE' });
+const iterationSchema = z.custom((v) => v instanceof Iteration, { message: 'INVALID_ITERATION_INSTANCE' });
+const qualifierMatchSchema = z.custom((v) => v instanceof QualifierMatch, { message: 'INVALID_QUALIFIER_MATCH_INSTANCE' });
+const regionSchema = z.custom((v) => typeof v === 'object' && v != null && 'name' in v && 'code' in v, {
+    message: 'INVALID_REGION'
+});
+export const QualifierInputSchema = z.object({
+    id: z.uuid(),
+    iteration: iterationSchema,
+    matches: z.array(qualifierMatchSchema),
+    teams: z.array(teamSchema),
+    status: z.enum(Object.values(StatusEnum)),
+    region: regionSchema,
+    champion: teamSchema.optional()
+}).superRefine((data, ctx) => {
+    const ids = data.teams.map(t => t.id);
+    if (new Set(ids).size !== ids.length) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'QUALIFIER_TEAMS_CONTAINS_DUPLICATES',
+            path: ['teams']
+        });
+    }
+});