nhl-api-ts 0.2.0 → 0.3.0

package/dist/cli/commands.mjs

@@ -5,7 +5,9 @@ import { SKATER_REPORT_TYPES } from '#src/api/query/sorting/sorting-options.mjs'
 export class UsageError extends Error {
 }
 // ---- Reusable argument specs ------------------------------------------------
-const req = (spec) => ({ ...spec, required: true });
+function req(spec) {
+    return { ...spec, required: true };
+}
 const teamAbbr = req({
     name: 'teamAbbr',
     type: 'string',
@@ -26,11 +28,13 @@ const playerId = req({
     type: 'string',
     description: 'NHL player id, e.g. 8478402',
 });
-const date = (description = 'Date in YYYY-MM-DD format') => ({
-    name: 'date',
-    type: 'string',
-    description,
-});
+function date(description = 'Date in YYYY-MM-DD format') {
+    return {
+        name: 'date',
+        type: 'string',
+        description,
+    };
+}
 const gameTypeId = {
     name: 'gameTypeId',
     type: 'int',
@@ -48,40 +52,74 @@ const start = {
     description: 'Pagination offset',
     default: '0',
 };
-const limit = (def) => ({
-    name: 'limit',
-    type: 'int',
-    description: 'Max results',
-    default: def,
-});
-const factCayenneExp = (def) => ({
-    name: 'factCayenneExp',
-    type: 'string',
-    description: 'Base fact filter expression',
-    default: def,
-});
+function limit(def) {
+    return {
+        name: 'limit',
+        type: 'int',
+        description: 'Max results',
+        default: def,
+    };
+}
+function factCayenneExp(def) {
+    return {
+        name: 'factCayenneExp',
+        type: 'string',
+        description: 'Base fact filter expression',
+        default: def,
+    };
+}
 const defaultCayenneExp = {
     name: 'defaultCayenneExp',
     type: 'string',
     description: 'Overrides the generated cayenneExp filter entirely',
 };
-const apiSleepRate = (def) => ({
-    name: 'apiSleepRate',
-    type: 'number',
-    description: 'Seconds to sleep between per-team requests',
-    default: def,
-});
+const currentSeason = {
+    ...season,
+    description: `${season.description}. Defaults to current`,
+};
+const nowSeason = {
+    ...season,
+    description: `${season.description}. Defaults to now`,
+};
+const draftSeason = {
+    name: 'season',
+    type: 'string',
+    description: 'Draft year in YYYY format, e.g. 2023. Defaults to now',
+};
+const seasonGameType = {
+    name: 'gameType',
+    type: 'int',
+    description: '2=Regular season, 3=Playoffs (only used with --season)',
+    default: '2',
+};
+const allTimeSeason = {
+    ...season,
+    description: `${season.description}. Defaults to every season`,
+};
+function leaderCategories(choices) {
+    return {
+        name: 'categories',
+        type: 'list',
+        description: `Comma-separated categories (${choices.join(', ')}). Defaults to all`,
+    };
+}
+const leaderLimit = {
+    name: 'limit',
+    type: 'int',
+    description: 'Rows per category (-1 for all)',
+    default: '5',
+};
+function apiSleepRate(def) {
+    return {
+        name: 'apiSleepRate',
+        type: 'number',
+        description: 'Seconds to sleep between per-team requests',
+        default: def,
+    };
+}
 // ---- Edge -------------------------------------------------------------------
-const edgeSeasonArgs = [
-    { ...season, description: `${season.description}. Defaults to current` },
-    {
-        name: 'gameType',
-        type: 'int',
-        description: '2=Regular season, 3=Playoffs (only used with --season)',
-        default: '2',
-    },
-];
-const edgeCommand = (name, method, idKind, description) => {
+const edgeSeasonArgs = [currentSeason, seasonGameType];
+function edgeCommand(name, method, idKind, description, extraArgs = []) {
     const idArg = idKind === 'player'
         ? [playerId]
         : idKind === 'team'
@@ -96,12 +134,62 @@ const edgeCommand = (name, method, idKind, description) => {
     return {
         name,
         description,
-        args: [...idArg, ...edgeSeasonArgs],
+        args: [...idArg, ...extraArgs, ...edgeSeasonArgs],
         run: (client, values) => 
         // biome-ignore lint/suspicious/noExplicitAny: dispatch by method name
         client.edge[method].call(client.edge, values),
     };
+}
+const edgePositions = {
+    name: 'positions',
+    type: 'string',
+    description: 'Player positions',
+    default: 'all',
+    choices: ['all', 'forwards', 'defense'],
 };
+const edgeStrength = {
+    name: 'strength',
+    type: 'string',
+    description: 'all, es (even strength), pp (power play) or pk (penalty kill)',
+    default: 'all',
+    choices: ['all', 'es', 'pp', 'pk'],
+};
+const edgeShotLocationCategory = {
+    name: 'category',
+    type: 'string',
+    description: 'Shot area: all, high (danger), mid (range) or long (range)',
+    default: 'all',
+    choices: ['all', 'high', 'mid', 'long'],
+};
+function edgeSortBy(choices) {
+    return req({
+        name: 'sortBy',
+        type: 'string',
+        description: 'Metric to rank by',
+        choices,
+    });
+}
+const edgeZoneSortBy = req({
+    name: 'sortBy',
+    type: 'string',
+    description: 'Zone to rank by',
+    choices: ['offensive', 'neutral', 'defensive'],
+});
+const distanceSortBy = edgeSortBy([
+    'total',
+    'per-60',
+    'max-game',
+    'max-period',
+]);
+const skatingSpeedSortBy = edgeSortBy(['max', 'over-22', '20-22', '18-20']);
+const shotSpeedSortBy = edgeSortBy([
+    'max',
+    'over-100',
+    '90-99',
+    '80-89',
+    '70-79',
+]);
+const shotLocationSortBy = edgeSortBy(['sog', 'goals', 'shooting-pctg']);
 // ---- Stats query-context filters --------------------------------------------
 const queryFilterArgs = [
     {
@@ -247,15 +335,45 @@ export const MODULES = [
             {
                 name: 'team-roster',
                 description: 'Roster for a team and season',
-                args: [teamAbbr, req(season)],
+                args: [teamAbbr, currentSeason],
                 run: (client, values) => client.teams.teamRoster(values),
             },
+            {
+                name: 'roster-seasons',
+                description: 'Every season a team has a roster for',
+                args: [teamAbbr],
+                run: (client, values) => client.teams.rosterSeasons(values),
+            },
+            {
+                name: 'team-scoreboard',
+                description: "A team's recent and upcoming games",
+                args: [teamAbbr],
+                run: (client, values) => client.teams.teamScoreboard(values),
+            },
             {
                 name: 'franchises',
                 description: 'All past and current NHL franchises',
                 args: [],
                 run: (client) => client.teams.franchises(),
             },
+            {
+                name: 'stats-teams',
+                description: 'Every team in the stats API, past and present',
+                args: [],
+                run: (client) => client.teams.statsTeams(),
+            },
+            {
+                name: 'team-by-id',
+                description: 'One stats API team by its team id',
+                args: [
+                    req({
+                        name: 'teamId',
+                        type: 'string',
+                        description: 'NHL team id, e.g. 10',
+                    }),
+                ],
+                run: (client, values) => client.teams.teamById(values),
+            },
         ],
     },
     {
@@ -314,13 +432,13 @@ export const MODULES = [
             {
                 name: 'team-season-schedule',
                 description: "A team's full season schedule",
-                args: [teamAbbr, req(season)],
+                args: [teamAbbr, nowSeason],
                 run: (client, values) => client.schedule.teamSeasonSchedule(values),
             },
             {
                 name: 'calendar-schedule',
                 description: 'Schedule in calendar format for a date',
-                args: [req(date())],
+                args: [date('Date in YYYY-MM-DD format. Defaults to now')],
                 run: (client, values) => client.schedule.calendarSchedule(values),
             },
             {
@@ -342,6 +460,19 @@ export const MODULES = [
                 ],
                 run: (client, values) => client.schedule.playoffSeriesSchedule(values),
             },
+            {
+                name: 'playoff-series-meta',
+                description: 'Round title and seeded teams of one playoff series',
+                args: [
+                    req({ name: 'year', type: 'string', description: 'Year, e.g. 2024' }),
+                    req({
+                        name: 'series',
+                        type: 'string',
+                        description: 'Series letter: a-h first round ... o final',
+                    }),
+                ],
+                run: (client, values) => client.schedule.playoffSeriesMeta(values),
+            },
             {
                 name: 'playoff-bracket',
                 description: 'Full playoff bracket for a year',
@@ -406,6 +537,37 @@ export const MODULES = [
                 args: [gameId],
                 run: (client, values) => client.gameCenter.gameStory(values),
             },
+            {
+                name: 'scoreboard',
+                description: 'Every game in the week around a date, grouped by date',
+                args: [date('Date in YYYY-MM-DD format. Defaults to now')],
+                run: (client, values) => client.gameCenter.scoreboard(values),
+            },
+            {
+                name: 'wsc-play-by-play',
+                description: 'Flat play-by-play feed used by the nhl.com game story',
+                args: [gameId],
+                run: (client, values) => client.gameCenter.wscPlayByPlay(values),
+            },
+            {
+                name: 'play-replay',
+                description: 'Replay card for one play-by-play event',
+                args: [
+                    gameId,
+                    req({
+                        name: 'eventNumber',
+                        type: 'string',
+                        description: "The play's eventId from play-by-play, e.g. 193",
+                    }),
+                ],
+                run: (client, values) => client.gameCenter.playReplay(values),
+            },
+            {
+                name: 'game-meta',
+                description: 'Teams, season state and game state for a game',
+                args: [gameId],
+                run: (client, values) => client.gameCenter.gameMeta(values),
+            },
         ],
     },
     {
@@ -429,19 +591,63 @@ export const MODULES = [
                 description: "A player's game log for a season",
                 args: [
                     playerId,
-                    req({
+                    {
                         name: 'seasonId',
                         type: 'string',
-                        description: 'Season in YYYYYYYY format',
-                    }),
-                    req({
+                        description: 'Season in YYYYYYYY format. Defaults to now',
+                    },
+                    {
                         name: 'gameType',
                         type: 'int',
-                        description: '1=Preseason, 2=Regular, 3=Playoffs',
-                    }),
+                        description: '1=Preseason, 2=Regular, 3=Playoffs (only used with --season-id)',
+                        default: '2',
+                    },
                 ],
                 run: (client, values) => client.stats.playerGameLog(values),
             },
+            {
+                name: 'skater-stats-leaders',
+                description: 'Skater stats leaders by category for a season',
+                args: [
+                    currentSeason,
+                    seasonGameType,
+                    leaderCategories([
+                        'goals',
+                        'assists',
+                        'points',
+                        'plusMinus',
+                        'penaltyMins',
+                        'goalsPp',
+                        'goalsSh',
+                        'faceoffLeaders',
+                        'toi',
+                    ]),
+                    leaderLimit,
+                ],
+                run: (client, values) => client.stats.skaterStatsLeaders(values),
+            },
+            {
+                name: 'goalie-stats-leaders',
+                description: 'Goalie stats leaders by category for a season',
+                args: [
+                    currentSeason,
+                    seasonGameType,
+                    leaderCategories([
+                        'wins',
+                        'shutouts',
+                        'savePctg',
+                        'goalsAgainstAverage',
+                    ]),
+                    leaderLimit,
+                ],
+                run: (client, values) => client.stats.goalieStatsLeaders(values),
+            },
+            {
+                name: 'club-stats',
+                description: "A team's skater and goalie stats for a season",
+                args: [teamAbbr, nowSeason, seasonGameType],
+                run: (client, values) => client.stats.clubStats(values),
+            },
             {
                 name: 'team-summary',
                 description: 'Team summary stats across seasons',
@@ -575,6 +781,52 @@ export const MODULES = [
                 ],
                 run: (client, values) => client.stats.goalieStatsSummary(values),
             },
+            {
+                name: 'skater-leaders',
+                description: 'Top 10 single-season skater records for a stat (stats API)',
+                args: [
+                    req({
+                        name: 'attribute',
+                        type: 'string',
+                        description: 'Stat to rank by',
+                        choices: ['points', 'goals', 'assists', 'gamesPlayed'],
+                    }),
+                    allTimeSeason,
+                ],
+                run: (client, values) => client.stats.skaterLeaders(values),
+            },
+            {
+                name: 'goalie-leaders',
+                description: 'Top 10 single-season goalie records for a stat (stats API)',
+                args: [
+                    req({
+                        name: 'attribute',
+                        type: 'string',
+                        description: 'Stat to rank by',
+                        choices: [
+                            'gaa',
+                            'savePctg',
+                            'shutouts',
+                            'timeOnIce',
+                            'gamesPlayed',
+                        ],
+                    }),
+                    allTimeSeason,
+                ],
+                run: (client, values) => client.stats.goalieLeaders(values),
+            },
+            {
+                name: 'skater-milestones',
+                description: 'Career milestones active skaters are approaching',
+                args: [],
+                run: (client) => client.stats.skaterMilestones(),
+            },
+            {
+                name: 'goalie-milestones',
+                description: 'Career milestones active goalies are approaching',
+                args: [],
+                run: (client) => client.stats.goalieMilestones(),
+            },
         ],
     },
     {
@@ -604,11 +856,29 @@ export const MODULES = [
             edgeCommand('team-landing', 'teamLanding', 'none', 'EDGE team landing page (league leaders)'),
             edgeCommand('team-shot-speed-detail', 'teamShotSpeedDetail', 'team', 'EDGE team shot speed'),
             edgeCommand('team-skating-speed-detail', 'teamSkatingSpeedDetail', 'team', 'EDGE team skating speed'),
+            edgeCommand('team-comparison', 'teamComparison', 'team', 'EDGE team comparison stats'),
+            edgeCommand('skater-distance-top-10', 'skaterDistanceTop10', 'none', 'EDGE top 10 skaters by skating distance', [edgePositions, edgeStrength, distanceSortBy]),
+            edgeCommand('skater-speed-top-10', 'skaterSpeedTop10', 'none', 'EDGE top 10 skaters by skating speed', [edgePositions, skatingSpeedSortBy]),
+            edgeCommand('skater-zone-time-top-10', 'skaterZoneTimeTop10', 'none', 'EDGE top 10 skaters by zone time', [edgePositions, edgeStrength, edgeZoneSortBy]),
+            edgeCommand('skater-shot-speed-top-10', 'skaterShotSpeedTop10', 'none', 'EDGE top 10 skaters by shot speed', [edgePositions, shotSpeedSortBy]),
+            edgeCommand('skater-shot-location-top-10', 'skaterShotLocationTop10', 'none', 'EDGE top 10 skaters by shot location', [edgePositions, shotLocationSortBy, edgeShotLocationCategory]),
+            edgeCommand('goalie-5v5-top-10', 'goalie5v5Top10', 'none', 'EDGE top 10 goalies at 5v5', [edgeSortBy(['save-pctg', 'save-pctg-close', 'shots', 'shots-per-60'])]),
+            edgeCommand('goalie-shot-location-top-10', 'goalieShotLocationTop10', 'none', 'EDGE top 10 goalies by shot location', [
+                edgeSortBy(['save-pctg', 'saves', 'goals-against', 'shots-against']),
+                edgeShotLocationCategory,
+            ]),
+            edgeCommand('goalie-save-percentage-top-10', 'goalieSavePercentageTop10', 'none', 'EDGE top 10 goalies by games above .900', [edgeSortBy(['games', 'pctg'])]),
+            edgeCommand('team-skating-distance-top-10', 'teamSkatingDistanceTop10', 'none', 'EDGE top 10 teams by skating distance', [edgePositions, edgeStrength, distanceSortBy]),
+            edgeCommand('team-skating-speed-top-10', 'teamSkatingSpeedTop10', 'none', 'EDGE top 10 teams by skating speed', [edgePositions, skatingSpeedSortBy]),
+            edgeCommand('team-zone-time-top-10', 'teamZoneTimeTop10', 'none', 'EDGE top 10 teams by zone time', [edgeStrength, edgeZoneSortBy]),
+            edgeCommand('team-shot-speed-top-10', 'teamShotSpeedTop10', 'none', 'EDGE top 10 teams by shot speed', [edgePositions, shotSpeedSortBy]),
+            edgeCommand('team-shot-location-top-10', 'teamShotLocationTop10', 'none', 'EDGE top 10 teams by shot location', [edgePositions, shotLocationSortBy, edgeShotLocationCategory]),
+            edgeCommand('by-the-numbers', 'byTheNumbers', 'none', 'EDGE league highlights (latest night, or season bests with --season)'),
         ],
     },
     {
         name: 'players',
-        description: 'Prospects and team rosters',
+        description: 'Prospects, team rosters and player search',
         commands: [
             {
                 name: 'prospects-by-team',
@@ -619,9 +889,110 @@ export const MODULES = [
             {
                 name: 'players-by-team',
                 description: "A team's roster for a season",
-                args: [teamAbbr, req(season)],
+                args: [teamAbbr, currentSeason],
                 run: (client, values) => client.players.playersByTeam(values),
             },
+            {
+                name: 'player-spotlight',
+                description: 'Players featured in the nhl.com spotlight',
+                args: [],
+                run: (client) => client.players.playerSpotlight(),
+            },
+            {
+                name: 'player-search',
+                description: 'Search every player (needs a filter). At most 5 rows per page; page with --start',
+                args: [
+                    {
+                        name: 'name',
+                        type: 'string',
+                        description: 'Case-insensitive part of the full name, e.g. matth',
+                    },
+                    {
+                        name: 'teamId',
+                        type: 'string',
+                        description: 'NHL team id of the current team, e.g. 10',
+                    },
+                    {
+                        name: 'position',
+                        type: 'string',
+                        description: 'Position; F matches every forward',
+                        choices: ['C', 'L', 'R', 'D', 'G', 'F'],
+                    },
+                    {
+                        name: 'cayenneExp',
+                        type: 'string',
+                        description: 'Extra filter, e.g. sweaterNumber=34',
+                    },
+                    {
+                        name: 'sort',
+                        type: 'string',
+                        description: 'Field to sort by, e.g. lastName',
+                    },
+                    {
+                        name: 'dir',
+                        type: 'string',
+                        description: 'Sort direction',
+                        choices: ['ASC', 'DESC'],
+                    },
+                    start,
+                    {
+                        name: 'include',
+                        type: 'list',
+                        description: 'Comma-separated fields to return, e.g. id,fullName',
+                    },
+                    {
+                        name: 'exclude',
+                        type: 'list',
+                        description: 'Comma-separated fields to leave out',
+                    },
+                ],
+                run: (client, values) => client.players.playerSearch(values),
+            },
+        ],
+    },
+    {
+        name: 'draft',
+        description: 'Draft rankings, picks and the live draft tracker',
+        commands: [
+            {
+                name: 'rankings',
+                description: 'Central Scouting rankings for one prospect category',
+                args: [
+                    draftSeason,
+                    {
+                        name: 'category',
+                        type: 'int',
+                        description: '1=NA skater, 2=Intl skater, 3=NA goalie, 4=Intl goalie (only used with --season)',
+                        default: '1',
+                        choices: ['1', '2', '3', '4'],
+                    },
+                ],
+                run: (client, values) => client.draft.rankings(values),
+            },
+            {
+                name: 'tracker',
+                description: 'Live draft tracker for the current draft',
+                args: [],
+                run: (client) => client.draft.tracker(),
+            },
+            {
+                name: 'picks',
+                description: 'Picks of a draft. Without --season, round 1 of the current draft',
+                args: [
+                    draftSeason,
+                    {
+                        name: 'round',
+                        type: 'string',
+                        description: 'Round 1-7 or all (only used with --season)',
+                        default: 'all',
+                        choices: ['1', '2', '3', '4', '5', '6', '7', 'all'],
+                    },
+                ],
+                run: (client, { round, ...values }) => client.draft.picks({
+                    ...values,
+                    round: round === undefined || round === 'all' ? round : Number(round),
+                }),
+            },
         ],
     },
     {
@@ -658,6 +1029,110 @@ export const MODULES = [
                 args: [],
                 run: (client) => client.misc.draftYearAndRounds(),
             },
+            {
+                name: 'component-seasons',
+                description: 'Season and game type the stats API serves by default',
+                args: [],
+                run: (client) => client.misc.componentSeasons(),
+            },
+            {
+                name: 'ping',
+                description: 'Check that the stats API is up (prints true)',
+                args: [],
+                run: (client) => client.misc.ping(),
+            },
+            {
+                name: 'games',
+                description: 'Games from the stats API (needs at least one filter)',
+                args: [
+                    season,
+                    {
+                        name: 'gameType',
+                        type: 'int',
+                        description: '1=Preseason, 2=Regular season, 3=Playoffs',
+                    },
+                    {
+                        name: 'teamId',
+                        type: 'string',
+                        description: 'NHL team id, home or away, e.g. 10',
+                    },
+                    {
+                        name: 'startDate',
+                        type: 'string',
+                        description: 'First game date, YYYY-MM-DD',
+                    },
+                    {
+                        name: 'endDate',
+                        type: 'string',
+                        description: 'Last game date, YYYY-MM-DD',
+                    },
+                    {
+                        name: 'cayenneExp',
+                        type: 'string',
+                        description: 'Extra filter, e.g. homeScore>=7',
+                    },
+                ],
+                run: (client, values) => client.misc.games(values),
+            },
+            {
+                name: 'tv-schedule',
+                description: 'National TV broadcasts for the week around a date',
+                args: [date('Date in YYYY-MM-DD format. Defaults to now')],
+                run: (client, values) => client.misc.tvSchedule(values),
+            },
+            {
+                name: 'partner-game-odds',
+                description: "Betting odds for today's games from a country's partner",
+                args: [
+                    req({
+                        name: 'countryCode',
+                        type: 'string',
+                        description: 'Two-letter country code, e.g. US, CA',
+                    }),
+                ],
+                run: (client, values) => client.misc.partnerGameOdds(values),
+            },
+            {
+                name: 'season-ids',
+                description: 'Every NHL season id, oldest first',
+                args: [],
+                run: (client) => client.misc.seasonIds(),
+            },
+            {
+                name: 'meta',
+                description: 'Display metadata for players and teams',
+                args: [
+                    {
+                        name: 'players',
+                        type: 'int-list',
+                        description: 'Comma-separated player ids, e.g. 8478402,8476945',
+                    },
+                    {
+                        name: 'teams',
+                        type: 'list',
+                        description: 'Comma-separated team abbreviations, e.g. TOR,BUF',
+                    },
+                ],
+                run: (client, values) => client.misc.meta(values),
+            },
+            {
+                name: 'location',
+                description: "The caller's country, from their IP address",
+                args: [],
+                run: (client) => client.misc.location(),
+            },
+            {
+                name: 'postal-lookup',
+                description: 'Teams whose broadcast market covers a postal code',
+                args: [
+                    req({
+                        name: 'postalCode',
+                        type: 'string',
+                        description: 'Postal or ZIP code, e.g. 90210',
+                    }),
+                ],
+                run: (client, values) => client.misc.postalLookup(values),
+            },
         ],
     },
     {