volleyballsimtypes 0.0.356 → 0.0.358

package/dist/cjs/src/api/index.d.ts

@@ -0,0 +1,127 @@
+import { BoxScore, DataProps, Division as _Division, League as _League, Match as _Match, MatchSet as _MatchSet, Player as _Player, PlayerPosition, Qualifier as _Qualifier, QualifierMatch as _QualifierMatch, Rally as _Rally, RallyEvent as _RallyEvent, Season as _Season, Standing as _Standing, Team as _Team, Tournament as _Tournament, TournamentMatch as _TournamentMatch, Country as _Country, CourtPosition } from '../service';
+export type Rally = DataProps<_Rally> & {
+    homePlayerPosition: PlayerPosition[];
+    awayPlayerPosition: PlayerPosition[];
+    events: RallyEvent[];
+};
+export type MatchSet = Omit<DataProps<_MatchSet>, 'rallies' | '_homeScore' | '_awayScore' | 'homeScore' | 'awayScore'> & {
+    homeLibero?: Player;
+    awayLibero?: Player;
+    rallies: Rally[];
+    homeScore: number;
+    awayScore: number;
+};
+export interface Results {
+    home: number[];
+    away: number[];
+}
+export type Match = Omit<DataProps<_Match>, 'sets' | 'homeTeam' | 'awayTeam' | 'VPERs'> & {
+    sets: MatchSet[];
+    boxScores: BoxScore[];
+    VPERs: VPER[];
+    homeTeam: Team;
+    awayTeam: Team;
+    season?: Season;
+    tournament?: Tournament;
+    qualifier?: Qualifier;
+    results?: Results;
+};
+export type RallyEvent = DataProps<_RallyEvent> & {
+    team?: Team;
+};
+export type Player = DataProps<_Player> & {
+    teamId: string;
+    jerseyNumber: number;
+    locked: boolean;
+};
+export interface StartingLineup {
+    [CourtPosition.LEFT_FRONT]: string;
+    [CourtPosition.MIDDLE_FRONT]: string;
+    [CourtPosition.RIGHT_FRONT]: string;
+    [CourtPosition.LEFT_BACK]: string;
+    [CourtPosition.MIDDLE_BACK]: string;
+    [CourtPosition.RIGHT_BACK]: string;
+    [CourtPosition.LIBERO_ZONE]?: string;
+    bench: string[];
+}
+export interface Tactics {
+    lineup: StartingLineup;
+    substitutionTolerance: number;
+    liberoReplacements: string[];
+    pinchServerSubs: Record<string, string>;
+}
+export type Team = Omit<DataProps<_Team>, 'roster' | '_rating' | 'rating' | 'tactics'> & {
+    roster: Player[];
+    rating: {
+        value: number;
+        lastChange?: number;
+    };
+    tactics?: Tactics;
+    leagueData?: {
+        division: {
+            tier: number;
+            subdivision: number;
+            name: string;
+        };
+        league: {
+            leagueId: string;
+            name: string;
+        };
+    };
+};
+export type Standing = DataProps<_Standing> & {
+    position: number;
+    iteration: number;
+};
+export type Season = Omit<DataProps<_Season>, 'teams' | 'matches' | 'champion' | 'standings'> & {
+    teams: Team[];
+    matches: Match[];
+    champion?: Team;
+    league?: _League;
+    standings: Standing[];
+};
+export type Division = Omit<DataProps<_Division>, 'seasons' | 'teams'> & {
+    teams: Team[];
+    seasons: Season[];
+};
+export type League = Omit<DataProps<_League>, 'divisions'> & {
+    divisions: Division[];
+};
+export type TournamentMatch = Omit<DataProps<_TournamentMatch>, 'match'> & {
+    match: Match;
+};
+export type Tournament = Omit<DataProps<_Tournament>, 'matches'> & {
+    matches: TournamentMatch[];
+};
+export type QualifierMatch = Omit<DataProps<_QualifierMatch>, 'match'> & {
+    match: Match;
+};
+export type Qualifier = Omit<DataProps<_Qualifier>, 'matches'> & {
+    matches: QualifierMatch[];
+};
+export interface VPER {
+    playerId: string;
+    value: number;
+}
+export type Country = Omit<DataProps<_Country>, 'league'> & {
+    league?: League;
+};
+export interface MVP {
+    totalVPER: number;
+    pointsPlayed: number;
+    avgVPER: number;
+    teamId: string;
+    player: Player;
+}
+export type TotalBoxScore = Omit<DataProps<BoxScore>, 'misc' | 'playerId' | 'matchSetId'> & {
+    player: Player;
+    misc: {
+        pointsPlayed: number;
+        pointsWonOnCourt: number;
+        serveTurns: number;
+        sideoutOpportunities: number;
+        successfulSideouts: number;
+        setsPlayed: number;
+        matchesPlayed: number;
+    };
+};

package/dist/cjs/src/api/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_1 = require("../service");

package/dist/cjs/src/data/common/auth-admin.d.ts

@@ -0,0 +1,7 @@
+import { Sequelize, Transaction } from 'sequelize';
+export interface EnsureAdminUserResult {
+    userId: string;
+    createdUser: boolean;
+    createdIdentity: boolean;
+}
+export declare function ensureDefaultAdminUser(sequelize: Sequelize, transaction?: Transaction): Promise<EnsureAdminUserResult>;

package/dist/cjs/src/data/common/auth-admin.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDefaultAdminUser = ensureDefaultAdminUser;
+const crypto_1 = require("crypto");
+const sequelize_1 = require("sequelize");
+function hashPassword(password) {
+    const salt = (0, crypto_1.randomBytes)(16).toString('hex');
+    const n = 16384;
+    const r = 8;
+    const p = 1;
+    const keyLength = 64;
+    const derived = (0, crypto_1.scryptSync)(password, salt, keyLength, { N: n, r, p });
+    return `scrypt$${n}$${r}$${p}$${salt}$${derived.toString('hex')}`;
+}
+async function ensureDefaultAdminUser(sequelize, transaction) {
+    const email = 'admin@example.com';
+    const password = 'admin123';
+    const displayName = 'Admin';
+    const now = new Date();
+    const passwordHash = hashPassword(password);
+    const run = async (tx) => {
+        const existingUsers = await sequelize.query(`
+      SELECT user_id
+      FROM "AuthUser"
+      WHERE lower(email) = lower(:email)
+      LIMIT 1
+      FOR UPDATE
+    `, {
+            replacements: { email },
+            type: sequelize_1.QueryTypes.SELECT,
+            transaction: tx
+        });
+        let userId;
+        let createdUser = false;
+        if (existingUsers.length === 0) {
+            userId = (0, crypto_1.randomUUID)();
+            createdUser = true;
+            await sequelize.query(`
+        INSERT INTO "AuthUser" (
+          user_id,
+          email,
+          role,
+          display_name,
+          status,
+          email_verified_at,
+          created_at,
+          updated_at
+        ) VALUES (
+          :userId,
+          :email,
+          'ADMIN',
+          :displayName,
+          'ACTIVE',
+          :now,
+          :now,
+          :now
+        )
+      `, {
+                replacements: { userId, email, displayName, now },
+                type: sequelize_1.QueryTypes.INSERT,
+                transaction: tx
+            });
+        }
+        else {
+            userId = existingUsers[0].user_id;
+            await sequelize.query(`
+        UPDATE "AuthUser"
+        SET email = :email,
+            role = 'ADMIN',
+            display_name = :displayName,
+            status = 'ACTIVE',
+            email_verified_at = COALESCE(email_verified_at, :now),
+            updated_at = :now
+        WHERE user_id = :userId
+      `, {
+                replacements: { userId, email, displayName, now },
+                type: sequelize_1.QueryTypes.UPDATE,
+                transaction: tx
+            });
+        }
+        const existingIdentities = await sequelize.query(`
+      SELECT identity_id, user_id
+      FROM "AuthIdentity"
+      WHERE provider = 'EMAIL'
+        AND lower(provider_user_id) = lower(:email)
+      LIMIT 1
+      FOR UPDATE
+    `, {
+            replacements: { email },
+            type: sequelize_1.QueryTypes.SELECT,
+            transaction: tx
+        });
+        let createdIdentity = false;
+        if (existingIdentities.length === 0) {
+            createdIdentity = true;
+            await sequelize.query(`
+        INSERT INTO "AuthIdentity" (
+          identity_id,
+          user_id,
+          provider,
+          provider_user_id,
+          email,
+          password_hash,
+          created_at,
+          updated_at
+        ) VALUES (
+          :identityId,
+          :userId,
+          'EMAIL',
+          :email,
+          :email,
+          :passwordHash,
+          :now,
+          :now
+        )
+      `, {
+                replacements: {
+                    identityId: (0, crypto_1.randomUUID)(),
+                    userId,
+                    email,
+                    passwordHash,
+                    now
+                },
+                type: sequelize_1.QueryTypes.INSERT,
+                transaction: tx
+            });
+        }
+        else {
+            const identity = existingIdentities[0];
+            if (identity.user_id !== userId) {
+                throw new Error(`ADMIN_EMAIL_IDENTITY_BELONGS_TO_DIFFERENT_USER email=${email} identityUser=${identity.user_id} adminUser=${userId}`);
+            }
+            await sequelize.query(`
+        UPDATE "AuthIdentity"
+        SET email = :email,
+            password_hash = :passwordHash,
+            updated_at = :now
+        WHERE identity_id = :identityId
+      `, {
+                replacements: {
+                    identityId: identity.identity_id,
+                    email,
+                    passwordHash,
+                    now
+                },
+                type: sequelize_1.QueryTypes.UPDATE,
+                transaction: tx
+            });
+        }
+        return { userId, createdUser, createdIdentity };
+    };
+    if (transaction != null) {
+        return await run(transaction);
+    }
+    return await sequelize.transaction(async (tx) => await run(tx));
+}

package/dist/cjs/src/data/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './status';
+export * from './auth-admin';

package/dist/cjs/src/data/common/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("./status"), exports);
+__exportStar(require("./auth-admin"), exports);

package/dist/cjs/src/data/common/status.d.ts

@@ -0,0 +1,8 @@
+import { EnumDataType } from 'sequelize';
+export declare enum StatusEnum {
+    PENDING = "PENDING",
+    IN_PROGRESS = "IN_PROGRESS",
+    COMPLETE = "COMPLETE"
+}
+export type Status = StatusEnum.PENDING | StatusEnum.IN_PROGRESS | StatusEnum.COMPLETE;
+export declare const StatusDataType: EnumDataType<Status>;

package/dist/cjs/src/data/common/status.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusDataType = exports.StatusEnum = void 0;
+const sequelize_1 = require("sequelize");
+var StatusEnum;
+(function (StatusEnum) {
+    StatusEnum["PENDING"] = "PENDING";
+    StatusEnum["IN_PROGRESS"] = "IN_PROGRESS";
+    StatusEnum["COMPLETE"] = "COMPLETE";
+})(StatusEnum || (exports.StatusEnum = StatusEnum = {}));
+exports.StatusDataType = sequelize_1.DataTypes.ENUM(...Object.values(StatusEnum));