volleyballsimtypes 0.0.1

package/src/data/transformers/set.ts

@@ -0,0 +1,98 @@
+import { Rally, Set, SetFailure, SetType } from '../../service'
+import { SetAttributes, SetModel } from '../models'
+import { transformFromEventType, transformToEventType } from './event-type'
+import { transformFromCourtTarget, transformToCourtTarget } from './court-target'
+import { transformToPlayer } from './player'
+import { APISet } from '../../routing'
+
+type setFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS'
+type serveType = 'OVERHAND' | 'UNDERHAND' | 'SPIKE' | 'DUMP'
+
+function transformToSetFailure (failure: SetFailure): setFailure {
+  switch (failure) {
+    case SetFailure.NO_FAILURE:
+      return 'NO_FAILURE'
+    case SetFailure.FAULT:
+      return 'FAULT'
+    case SetFailure.MISS:
+      return 'MISS'
+    case SetFailure.OUT_OF_BOUNDS:
+      return 'OUT_OF_BOUNDS'
+    case SetFailure.BAD_PASS:
+      return 'BAD_PASS'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromSetFailure (failure: setFailure): SetFailure {
+  return SetFailure[failure]
+}
+
+function transformToSetType (type: SetType): serveType {
+  switch (type) {
+    case SetType.OVERHAND:
+      return 'OVERHAND'
+    case SetType.UNDERHAND:
+      return 'UNDERHAND'
+    case SetType.SPIKE:
+      return 'SPIKE'
+    case SetType.DUMP:
+      return 'DUMP'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromSetType (type: serveType): SetType {
+  return SetType[type]
+}
+
+function transformToAttributes (event: Set, rally: Rally): SetAttributes {
+  return {
+    event_id: event.id,
+    player_id: event.player.id,
+    rally_id: rally.id,
+    order: event.order,
+    modifier: event.modifier,
+    score: event.score,
+    target: transformFromCourtTarget(event.target),
+    failure: transformToSetFailure(event.failure),
+    type: transformToSetType(event.type),
+    event_type: transformFromEventType(event.eventType)
+  }
+}
+
+function transformToObject (set: SetModel): Set {
+  return new Set({
+    id: set.event_id,
+    eventType: transformToEventType(set.event_type),
+    failure: transformFromSetFailure(set.failure),
+    type: transformFromSetType(set.type),
+    player: transformToPlayer(set.player),
+    target: transformToCourtTarget(set.target),
+    modifier: set.modifier,
+    order: set.order,
+    score: set.score
+  })
+}
+
+function transformToAPIObject (event: SetModel): APISet {
+  return {
+    id: event.event_id,
+    eventType: transformToEventType(event.event_type),
+    failure: transformFromSetFailure(event.failure),
+    type: transformFromSetType(event.type),
+    playerId: event.player_id,
+    target: transformToCourtTarget(event.target),
+    modifier: event.modifier,
+    order: event.order,
+    score: event.score
+  }
+}
+
+export {
+  transformToObject as transformToSet,
+  transformToAPIObject as transformToAPISet,
+  transformToAttributes as transformFromSet
+}

package/src/data/transformers/spike.ts

@@ -0,0 +1,102 @@
+import { Rally, Spike, SpikeFailure, SpikeType } from '../../service'
+import { SpikeAttributes, SpikeModel } from '../models'
+import { transformFromEventType, transformToEventType } from './event-type'
+import { transformFromCourtTarget, transformToCourtTarget } from './court-target'
+import { transformToPlayer } from './player'
+import { APISpike } from '../../routing'
+
+type spikeFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'NET'
+type spikeType = 'CROSS_SHOT' | 'LINE_SHOT' | 'TOOL_SHOT' | 'TIP' | 'DOWN_BALL' | 'OVERHAND'
+
+function transformToSpikeFailure (failure: SpikeFailure): spikeFailure {
+  switch (failure) {
+    case SpikeFailure.NO_FAILURE:
+      return 'NO_FAILURE'
+    case SpikeFailure.FAULT:
+      return 'FAULT'
+    case SpikeFailure.MISS:
+      return 'MISS'
+    case SpikeFailure.OUT_OF_BOUNDS:
+      return 'OUT_OF_BOUNDS'
+    case SpikeFailure.NET:
+      return 'NET'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromSpikeFailure (failure: spikeFailure): SpikeFailure {
+  return SpikeFailure[failure]
+}
+
+function transformToSpikeType (type: SpikeType): spikeType {
+  switch (type) {
+    case SpikeType.CROSS_SHOT:
+      return 'CROSS_SHOT'
+    case SpikeType.LINE_SHOT:
+      return 'LINE_SHOT'
+    case SpikeType.TOOL_SHOT:
+      return 'TOOL_SHOT'
+    case SpikeType.TIP:
+      return 'TIP'
+    case SpikeType.DOWN_BALL:
+      return 'DOWN_BALL'
+    case SpikeType.OVERHAND:
+      return 'OVERHAND'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromSpikeType (type: spikeType): SpikeType {
+  return SpikeType[type]
+}
+
+function transformToAttributes (event: Spike, rally: Rally): SpikeAttributes {
+  return {
+    event_id: event.id,
+    player_id: event.player.id,
+    rally_id: rally.id,
+    order: event.order,
+    modifier: event.modifier,
+    score: event.score,
+    target: transformFromCourtTarget(event.target),
+    failure: transformToSpikeFailure(event.failure),
+    type: transformToSpikeType(event.type),
+    event_type: transformFromEventType(event.eventType)
+  }
+}
+
+function transformToObject (spike: SpikeModel): Spike {
+  return new Spike({
+    id: spike.event_id,
+    eventType: transformToEventType(spike.event_type),
+    failure: transformFromSpikeFailure(spike.failure),
+    type: transformFromSpikeType(spike.type),
+    player: transformToPlayer(spike.player),
+    target: transformToCourtTarget(spike.target),
+    modifier: spike.modifier,
+    order: spike.order,
+    score: spike.score
+  })
+}
+
+function transformToAPIObject (event: SpikeModel): APISpike {
+  return {
+    id: event.event_id,
+    eventType: transformToEventType(event.event_type),
+    failure: transformFromSpikeFailure(event.failure),
+    type: transformFromSpikeType(event.type),
+    playerId: event.player_id,
+    target: transformToCourtTarget(event.target),
+    modifier: event.modifier,
+    order: event.order,
+    score: event.score
+  }
+}
+
+export {
+  transformToObject as transformToSpike,
+  transformToAPIObject as transformToAPISpike,
+  transformToAttributes as transformFromSpike
+}

package/src/data/transformers/substitution.ts

@@ -0,0 +1,42 @@
+import { Rally, Substitution } from '../../service'
+import { SubstitutionAttributes, SubstitutionModel } from '../models'
+import { transformFromEventType, transformToEventType } from './event-type'
+import { transformToPlayer } from './player'
+import { APISubstitution } from '../../routing'
+
+function transformToAttributes (event: Substitution, rally: Rally): SubstitutionAttributes {
+  return {
+    player_id: event.player.id,
+    event_id: event.id,
+    order: event.order,
+    event_type: transformFromEventType(event.eventType),
+    player_out: event.playerOut.id,
+    rally_id: rally.id
+  }
+}
+
+function transformToObject (event: SubstitutionModel): Substitution {
+  return new Substitution({
+    id: event.event_id,
+    player: transformToPlayer(event.player),
+    playerOut: transformToPlayer(event.player_out_Player),
+    order: event.order,
+    eventType: transformToEventType(event.event_type)
+  })
+}
+
+function transformToAPIObject (event: SubstitutionModel): APISubstitution {
+  return {
+    id: event.event_id,
+    eventType: transformToEventType(event.event_type),
+    playerId: event.player_id,
+    order: event.order,
+    playerOutId: event.player_out
+  }
+}
+
+export {
+  transformToObject as transformToSubstitution,
+  transformToAPIObject as transformToAPISubstitution,
+  transformToAttributes as transformFromSubstitution
+}

package/src/data/transformers/team.ts

@@ -0,0 +1,45 @@
+import { Team } from '../../service'
+import { TeamAttributes, TeamModel } from '../models'
+import { transformToCountry } from './country'
+import { transformToCoach } from './coach'
+import { transformToAPIPlayer, transformToPlayer } from './player'
+import { APITeam } from '../../routing'
+
+function transformToAttributes (team: Team): TeamAttributes {
+  return {
+    team_id: team.id,
+    name: team.name,
+    short_name: team.shortName,
+    coach_id: team.coach!.id,
+    country_id: team.country!.id,
+    league_id: team.league!.id
+  }
+}
+
+function transformToObject (team: TeamModel): Team {
+  return new Team({
+    id: team.team_id,
+    name: team.name,
+    shortName: team.short_name,
+    country: team.country != null ? transformToCountry(team.country) : undefined,
+    coach: team.coach != null ? transformToCoach(team.coach) : undefined,
+    roster: team.Players != null ? team.Players.map(transformToPlayer) : []
+  })
+}
+
+function transformToAPIObject (team: TeamModel): APITeam {
+  return {
+    id: team.team_id,
+    name: team.name,
+    shortName: team.short_name,
+    country: transformToCountry(team.country),
+    coach: transformToCoach(team.coach),
+    roster: team.Players != null ? team.Players.map(transformToAPIPlayer) : []
+  }
+}
+
+export {
+  transformToObject as transformToTeam,
+  transformToAPIObject as transformToAPITeam,
+  transformToAttributes as transformFromTeam
+}

package/src/data/transformers/trait.ts

@@ -0,0 +1,37 @@
+import { Trait } from '../../service/player/trait'
+import { APITrait } from '../../routing'
+
+type trait = 'MARKSMAN' | 'MOVING_WALL' | 'MASTER_MIND' | 'METEOR_SERVE' | 'VIGOROUS' | 'GUARDIAN'
+
+function transformToType (trait: Trait): trait {
+  switch (trait.name) {
+    case 'Marksman':
+      return 'MARKSMAN'
+    case 'Master Mind':
+      return 'MASTER_MIND'
+    case 'Moving Wall':
+      return 'MOVING_WALL'
+    case 'Meteor Serve':
+      return 'METEOR_SERVE'
+    case 'Vigorous':
+      return 'VIGOROUS'
+    case 'Guardian':
+      return 'GUARDIAN'
+    default:
+      throw new Error('UNKNOWN_TRAIT')
+  }
+}
+
+function transformFromType (trait: trait): Trait {
+  return Trait[trait]
+}
+
+function transformToEnum (trait: trait): APITrait {
+  return APITrait[trait]
+}
+
+export {
+  transformToType as transformFromTrait,
+  transformFromType as transformToTrait,
+  transformToEnum as transformToAPITrait
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import { validateRoleFormulas } from './service/main'
+
+validateRoleFormulas()
+
+export * from './service'
+export * from './routing'
+export * from './data'

package/src/routing/events.ts

@@ -0,0 +1,60 @@
+import { EventType } from '../service/event/rally-event'
+import { LiberoReplacementType } from '../service/event/libero-replacement'
+import { CourtTarget } from '../service/match'
+import { SpikeFailure, SpikeType } from '../service/event/spike'
+import { SetFailure, SetType } from '../service/event/set'
+import { ServeFailure, ServeType } from '../service/event/serve'
+import { BlockFailure, BlockType } from '../service/event/block'
+import { ReceptionFailure, ReceptionType } from '../service/event/reception'
+
+export interface APIEvent {
+  id: string
+  order: number
+  playerId: string
+  eventType: EventType
+}
+
+export interface APILiberoReplacement extends APIEvent {
+  type: LiberoReplacementType
+  liberoId: string
+}
+
+export interface APISubstitution extends APIEvent {
+  playerOutId: string
+}
+
+export interface APIInPlayEvent extends APIEvent {
+  target: CourtTarget
+  modifier: number
+  score: number
+}
+
+export interface APIScore extends APIEvent {
+  teamId: string
+}
+
+export interface APIServe extends APIInPlayEvent {
+  type: ServeType
+  failure: ServeFailure
+}
+
+export interface APISet extends APIInPlayEvent {
+  type: SetType
+  failure: SetFailure
+}
+
+export interface APISpike extends APIInPlayEvent {
+  failure: SpikeFailure
+  type: SpikeType
+}
+
+export interface APIReception extends APIInPlayEvent {
+  type: ReceptionType
+  failure: ReceptionFailure
+}
+
+export interface APIBlock extends APIInPlayEvent {
+  failure: BlockFailure
+  type: BlockType
+  blockers: string[]
+}

package/src/routing/index.ts

@@ -0,0 +1,5 @@
+export * from './events'
+export * from './league'
+export * from './match'
+export * from './player'
+export * from './team'

package/src/routing/league.ts

@@ -0,0 +1,15 @@
+import { League, Standing } from '../service/league'
+import { APITeam } from './team'
+import { APIMatch } from './match'
+
+export interface APILeague {
+  
+}
+export interface APISeason {
+  id: string
+  teams: APITeam[]
+  matches: APIMatch[]
+  iteration: number
+  standings: Standing[]
+  league: League
+}

package/src/routing/match.ts

@@ -0,0 +1,52 @@
+import { EventStat, PlayerPosition, SetStatistics } from '../service/match'
+import { APIEvent } from './events'
+import { Team } from '../service/team'
+import { Player } from '../service/player'
+import { APITeam } from './team'
+
+export interface APIMatch {
+  id: string
+  homeTeam: APITeam
+  awayTeam: APITeam
+  sets: APIMatchSet[]
+  scheduledDate: Date
+}
+
+export interface APIMatchSet {
+  id: string
+  order: number
+  isTieBreak: boolean
+  homeLiberoId: string | undefined
+  awayLiberoId: string | undefined
+  homeScore: number
+  awayScore: number
+  stats: APISetStatistics[]
+  rallies: APIRally[]
+}
+
+export interface APIRally {
+  id: string
+  servingTeamId: string
+  events: APIEvent[]
+  homePlayerPosition: PlayerPosition[]
+  awayPlayerPosition: PlayerPosition[]
+  order: number
+}
+
+export interface APISetStatistics {
+  order: number
+  playerId: string
+  ace: number
+  attempts: number
+  contacts: number
+  ralliesPlayed: number
+  serve: EventStat
+  reception: EventStat
+  set: EventStat
+  attack: EventStat
+  block: EventStat
+  kills: number
+  killBlocks: number
+  assists: number
+  setsPlayed?: number
+}

package/src/routing/player.ts

@@ -0,0 +1,24 @@
+import { Country } from '../service/country'
+import { Name, Role, Stat } from '../service/player'
+import { APISetStatistics } from './match'
+
+export enum APITrait {
+  MASTER_MIND = 'Master Mind',
+  MOVING_WALL = 'Moving Wall',
+  MARKSMAN = 'Marksman',
+  METEOR_SERVE = 'Meteor Serve',
+  VIGOROUS = 'Vigorous',
+  GUARDIAN = 'Guardian'
+}
+
+export interface APIPlayer {
+  id: string
+  name: Name
+  country: Country
+  gameStats: APISetStatistics[]
+  roles: Role[]
+  traits: APITrait[]
+  jerseyNumber: number
+  team: string
+  generalStats: Stat[]
+}

package/src/routing/team.ts

@@ -0,0 +1,14 @@
+import { Coach } from '../service/coach'
+import { Country } from '../service/country'
+import { APIPlayer } from './player'
+import { APILeague } from './league'
+
+export interface APITeam {
+  id: string
+  roster: APIPlayer[]
+  name: string
+  shortName: string
+  coach: Coach
+  country: Country
+  league?: string
+}

package/src/service/coach/__stubs__/index.ts

@@ -0,0 +1,46 @@
+import { Coach } from '../coach'
+import { Formation } from '../formation'
+import { countries, country } from '../../country/__stubs__'
+
+export const coaches = [
+  new Coach({
+    name: { first: 'Jameson', last: 'Richardson' },
+    id: '8cd3a3fb-2034-487c-a041-fb06de0e374b',
+    country: countries[0],
+    formation: Formation['4-2'],
+    substitutionTolerance: 5
+  }),
+  new Coach({
+    id: '1be93fd6-62c4-4434-aaa0-730212ab72d7',
+    name: { first: 'Hunter', last: 'Rivera' },
+    country: countries[1],
+    formation: Formation['5-1'],
+    substitutionTolerance: 5
+  }),
+  new Coach({
+    id: 'a96b6732-2a71-451e-8973-c264446c594d',
+    name: {
+      first: 'Jonathan',
+      last: 'Jenkins'
+    },
+    country: countries[2],
+    formation: Formation['5-1'],
+    substitutionTolerance: 5
+  }),
+  new Coach({
+    id: '34086150-9692-4371-a5a4-0349170339e7',
+    name: { first: 'Noah', last: 'Adams' },
+    country: countries[3],
+    formation: Formation['6-2'],
+    substitutionTolerance: 5
+  })
+
+]
+
+export const coach: Coach = new Coach({
+  id: '1ad40ceb-b5ad-4e20-953c-3c1f050ac61d',
+  formation: Formation['6-2'],
+  name: { first: 'Julio', last: 'Velasco' },
+  country,
+  substitutionTolerance: 5
+})

package/src/service/coach/coach.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, test } from '@jest/globals'
+import { coach } from './__stubs__'
+
+describe('Coach Test Module', () => {
+  test('Should instantiate object properly', () => {
+    expect(coach.id).toEqual('1ad40ceb-b5ad-4e20-953c-3c1f050ac61d')
+    expect(coach.name.first).toEqual('Julio')
+    expect(coach.name.last).toEqual('Velasco')
+  })
+})

package/src/service/coach/coach.ts

@@ -0,0 +1,30 @@
+import { Formation } from './formation'
+import { validateUUID } from '../utils'
+import { Name } from '../player'
+import { Country } from '../country'
+
+export interface CoachOpts {
+  readonly id: string
+  readonly name: Name
+  readonly country: Country
+  readonly formation?: Formation
+  readonly substitutionTolerance?: number
+}
+
+export class Coach {
+  readonly id: string
+  readonly name: Name
+  readonly country: Country
+  readonly formation?: Formation
+  readonly substitutionTolerance?: number
+
+  constructor ({ id, name, country, formation, substitutionTolerance }: CoachOpts) {
+    validateUUID(id)
+
+    this.id = id
+    this.name = name
+    this.country = country
+    this.formation = formation
+    this.substitutionTolerance = substitutionTolerance
+  }
+}

package/src/service/coach/formation.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, test } from '@jest/globals'
+
+describe('Formation Test Module', () => {
+  // getFormation Tests
+  test('Should return supported formations', () => {
+    // TODO
+
+    expect(1).toBe(1)
+  })
+})