@timmsy/riftjs 1.0.0 → 2.0.1

package/.github/workflows/publish.yml

@@ -0,0 +1,50 @@
+name: Publish package
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Validate tag matches package version
+        run: |
+          TAG_VERSION="${GITHUB_REF_NAME#v}"
+          PKG_VERSION="$(node -p "require('./package.json').version")"
+          if [ "$TAG_VERSION" != "$PKG_VERSION" ]; then
+            echo "Tag version v$TAG_VERSION does not match package.json version $PKG_VERSION"
+            exit 1
+          fi
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Publish to GitHub Packages
+        run: |
+          npm config set @timmsy:registry https://npm.pkg.github.com
+          npm publish --registry=https://npm.pkg.github.com
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 James Timms
+Copyright (c) 2026 James Timms
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,192 @@
+# RiftJS
+
+A lightweight Node.js wrapper for the Riot Games API, providing easy access to League of Legends game data.
+
+[![npm version](https://badge.fury.io/js/@timmsy%2Friftjs.svg)](https://www.npmjs.com/package/@timmsy/riftjs)
+![GitHub license](https://img.shields.io/github/license/timmsy1998/RiftJS)
+
+## Overview
+
+RiftJS simplifies interaction with the Riot Games API and DataDragon static data. It supports fetching account details, summoner info, match history, and game data using a modular endpoint structure. Built with `axios` and `dotenv`, it’s designed for developers building League of Legends tools or applications.
+
+## Features
+
+- **RiotAPI**: Fetch account data by Riot ID, summoner data by PUUID, match history, and match details.
+- **DataDragon**: Access static game data like champions and items.
+- **Region Support**: Handles platform (e.g., `EUW1`) and shard (e.g., `europe`) routing.
+- **Modular Design**: Endpoints are organized in an `/endpoints/` directory for easy extension.
+
+## Installation
+
+Install RiftJS via npm:
+
+```bash
+npm install @timmsy/riftjs
+```
+
+You’ll also need a Riot Games API key from [developer.riotgames.com](https://developer.riotgames.com/).
+
+## Setup
+
+1. **Install Dependencies**:
+   Ensure you have Node.js installed, then run the install command above.
+
+2. **Configure Environment**:
+   Create a `.env` file in your project root with your API key and region:
+
+   ```env
+   RIOT_API_KEY=RGAPI-your-api-key-here
+   REGION=EUW1
+   TEST_RIOT_ID=YourRiotName
+   TEST_TAG_LINE=EUW
+   ```
+
+   - Replace `RGAPI-your-api-key-here` with your API key.
+   - Use a short region code (e.g., `EUW1`, `NA1`). See [Region Mapping](#region-mapping) for details.
+   - `TEST_RIOT_ID` and `TEST_TAG_LINE` are used by the endpoint test script.
+
+## Usage
+
+Here’s a basic example to get started:
+
+```js
+const { RiotAPI, DataDragon } = require('@timmsy/riftjs');
+
+// Initialize RiotAPI
+const riot = new RiotAPI();
+
+// Fetch account, summoner, and match data
+async function fetchPlayerData() {
+  try {
+    const account = await riot.getAccountByRiotId('Timmsy#BRUV');
+    console.log('Account:', account);
+
+    const summoner = await riot.getSummonerByPuuid(account.puuid);
+    console.log('Summoner:', summoner);
+
+    const matchlist = await riot.getMatchlistByPuuid(account.puuid, { start: 0, count: 5 });
+    console.log('Matchlist:', matchlist);
+
+    const match = await riot.getMatchById(matchlist[0]);
+    console.log('Match:', match);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Initialize DataDragon
+const dd = new DataDragon();
+
+async function fetchStaticData() {
+  try {
+    const champions = await dd.getChampions();
+    console.log('Champions:', champions.data);
+
+    const items = await dd.getItems();
+    console.log('Items:', items.data);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Run the examples
+fetchPlayerData();
+fetchStaticData();
+```
+
+## API Reference
+
+### RiotAPI
+
+- `getAccountByRiotId(riotId, [tagLine], [region])`: Fetch account by Riot ID (e.g., `Timmsy#BRUV`).
+- `getSummonerByPuuid(puuid, [region])`: Get summoner data by PUUID.
+- `getMatchlistByPuuid(puuid, [options], [region])`: Get match history (options: `{ start, count }`).
+- `getMatchById(matchId, [region])`: Get full match payload (`metadata` + `info`) by match ID.
+- `getMatchTimelineById(matchId, [region])`: Get timeline payload by match ID.
+- `getMatchlistByPuuidAll(puuid, [options], [region], [pacing])`: Fetch all match IDs in pages of 100.
+- `getMatchesWithDetailsByPuuid(puuid, [options], [region], [pacing])`: Fetch all match IDs and their match payloads.
+
+`options` supports Riot Match-V5 query params:
+- `startTime` (epoch seconds)
+- `endTime` (epoch seconds)
+- `queue` (int)
+- `type` (string)
+- `start` (int, default `0`)
+- `count` (int, `0-100`, single-page method only)
+
+`pacing` helps respect rate limits on multi-request methods:
+- `getMatchlistByPuuidAll`: `{ delayMs, maxMatches }`
+- `getMatchesWithDetailsByPuuid`: `{ pageDelayMs, detailDelayMs, maxMatches }`
+
+### DataDragon
+
+- `getChampions()`: Fetch all champion data.
+- `getItems()`: Fetch all item data.
+- `new DataDragon()` resolves the latest Data Dragon patch automatically.
+- `new DataDragon('x.y.z')` pins requests to an explicit patch version.
+
+## Region Mapping
+
+RiftJS uses a region map to route requests correctly:
+
+- **Platform Routing** (e.g., Summoner V4):
+
+  - `EUW1` → `euw1.api.riotgames.com`
+  - `NA1` → `na1.api.riotgames.com`
+
+- **Shard Routing** (e.g., Account V1, Match V5):
+
+  - `EUW1` → `europe.api.riotgames.com`
+  - `NA1` → `americas.api.riotgames.com`
+
+Supported regions: `BR1`, `EUN1`, `EUW1`, `JP1`, `KR`, `LA1`, `LA2`, `NA1`, `OC1`, `TR1`, `RU`, `PH2`, `SG2`, `TH2`, `TW2`, `VN2`.
+
+## Keywords
+
+- riot-api
+- league-of-legends
+- lol-api
+- datadragon
+- summoner
+- match-history
+- game-data
+- node-js
+- javascript
+- api-wrapper
+
+## Development
+
+To contribute or run locally:
+
+1. Clone the repo:
+
+   ```bash
+   git clone https://github.com/timmsy1998/RiftJS.git
+   cd RiftJS
+   ```
+
+2. Install dependencies:
+
+   ```bash
+   npm install
+   ```
+
+3. Create a `.env` file (see [Setup](#setup)).
+4. Run endpoint checks:
+
+   ```bash
+   npm test
+   ```
+
+   - Riot API calls run when `TEST_RIOT_ID` is set.
+   - Data Dragon calls always run.
+
+## License
+
+MIT License © 2025 James Timms. See [LICENSE](LICENSE) for details.
+
+## Links
+
+- **npm Registry**: [https://www.npmjs.com/package/@timmsy/riftjs](https://www.npmjs.com/package/@timmsy/riftjs)
+- **GitHub Repository**: [https://github.com/timmsy1998/RiftJS](https://github.com/timmsy1998/RiftJS)
+- **Riot Developer Portal**: [https://developer.riotgames.com/](https://developer.riotgames.com/)

package/endpoints/datadragon.js

@@ -0,0 +1,40 @@
+const axios = require('axios');
+
+module.exports = (baseURLOrResolver) => {
+    const resolveBaseURL = async () => {
+        if (typeof baseURLOrResolver === 'function') {
+            return baseURLOrResolver();
+        }
+        return baseURLOrResolver;
+    };
+
+    return {
+        /**
+         * Fetch champion metadata for the configured Data Dragon version/locale.
+         * @returns {Promise<object>} Champion data.
+         */
+        async getChampions() {
+            try {
+                const baseURL = await resolveBaseURL();
+                const response = await axios.get(`${baseURL}/champion.json`);
+                return response.data;
+            } catch (error) {
+                throw new Error(`DataDragon error: ${error.message}`);
+            }
+        },
+
+        /**
+         * Fetch item metadata for the configured Data Dragon version/locale.
+         * @returns {Promise<object>} Item data.
+         */
+        async getItems() {
+            try {
+                const baseURL = await resolveBaseURL();
+                const response = await axios.get(`${baseURL}/item.json`);
+                return response.data;
+            } catch (error) {
+                throw new Error(`DataDragon error: ${error.message}`);
+            }
+        },
+    };
+};

package/endpoints/riot.js

@@ -0,0 +1,176 @@
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+module.exports = (client, defaultRegion, regionMap) => ({
+    /**
+     * Fetch account data by Riot ID.
+     * @param {string} riotId - Riot ID (e.g., "Timmsy#BRUV" or "Timmsy", "BRUV").
+     * @param {string} [tagLine] - Optional tagLine if not included in riotId.
+     * @param {string} [region] - Region code used to resolve shard routing.
+     * @returns {Promise<object>} Account payload including `puuid`.
+     */
+    async getAccountByRiotId(riotId, tagLine = null, region = defaultRegion) {
+        let gameName, tag;
+        if (riotId.includes('#')) {
+            [gameName, tag] = riotId.split('#');
+        } else {
+            gameName = riotId;
+            tag = tagLine || '';
+        }
+        if (!tag) throw new Error('TagLine is required for getAccountByRiotId');
+        const shard = regionMap[region].shard;
+        try {
+            const response = await client.get(`/riot/account/v1/accounts/by-riot-id/${encodeURIComponent(gameName)}/${encodeURIComponent(tag)}`, {
+                baseURL: `https://${shard}`,
+            });
+            return response.data;
+        } catch (error) {
+            throw this._handleError(error);
+        }
+    },
+
+    /**
+     * Fetch Summoner-V4 data for a player's PUUID.
+     * @param {string} puuid - Encrypted PUUID.
+     * @param {string} [region] - Region code used to resolve platform routing.
+     * @returns {Promise<object>} Summoner payload.
+     */
+    async getSummonerByPuuid(puuid, region = defaultRegion) {
+        const platform = regionMap[region].platform;
+        try {
+            const response = await client.get(`/lol/summoner/v4/summoners/by-puuid/${encodeURIComponent(puuid)}`, {
+                baseURL: `https://${platform}`,
+            });
+            return response.data;
+        } catch (error) {
+            throw this._handleError(error);
+        }
+    },
+
+    /**
+     * Fetch match IDs for a PUUID from Match-V5.
+     * @param {string} puuid - Player PUUID.
+     * @param {object} [options] - Query params such as `start` and `count`.
+     * @param {string} [region] - Region code used to resolve shard routing.
+     * @returns {Promise<string[]>} Array of match IDs.
+     */
+    async getMatchlistByPuuid(puuid, options = {}, region = defaultRegion) {
+        const shard = regionMap[region].shard;
+        try {
+            const response = await client.get(`/lol/match/v5/matches/by-puuid/${encodeURIComponent(puuid)}/ids`, {
+                baseURL: `https://${shard}`,
+                params: options,
+            });
+            return response.data;
+        } catch (error) {
+            throw this._handleError(error);
+        }
+    },
+
+    /**
+     * Fetch full match details by match ID.
+     * @param {string} matchId - Match ID (e.g., "EUW1_1234567890").
+     * @param {string} [region] - Region code used to resolve shard routing.
+     * @returns {Promise<object>} Match payload.
+     */
+    async getMatchById(matchId, region = defaultRegion) {
+        const shard = regionMap[region].shard;
+        try {
+            const response = await client.get(`/lol/match/v5/matches/${matchId}`, {
+                baseURL: `https://${shard}`,
+            });
+            return response.data;
+        } catch (error) {
+            throw this._handleError(error);
+        }
+    },
+
+    /**
+     * Fetch match timeline data by match ID.
+     * @param {string} matchId - Match ID (e.g., "EUW1_1234567890").
+     * @param {string} [region] - Region code used to resolve shard routing.
+     * @returns {Promise<object>} Match timeline payload.
+     */
+    async getMatchTimelineById(matchId, region = defaultRegion) {
+        const shard = regionMap[region].shard;
+        try {
+            const response = await client.get(`/lol/match/v5/matches/${matchId}/timeline`, {
+                baseURL: `https://${shard}`,
+            });
+            return response.data;
+        } catch (error) {
+            throw this._handleError(error);
+        }
+    },
+
+    /**
+     * Fetch all match IDs for a PUUID using Riot's max page size (100).
+     * @param {string} puuid - Player PUUID.
+     * @param {object} [options] - Riot filters: startTime, endTime, queue, type, start.
+     * @param {string} [region] - Region code used to resolve shard routing.
+     * @param {object} [pacing] - Pacing controls.
+     * @param {number} [pacing.delayMs=1250] - Delay between page requests.
+     * @param {number|null} [pacing.maxMatches=null] - Optional cap on total IDs returned.
+     * @returns {Promise<string[]>} All matched IDs.
+     */
+    async getMatchlistByPuuidAll(puuid, options = {}, region = defaultRegion, pacing = {}) {
+        const baseStart = Number.isInteger(options.start) ? options.start : 0;
+        const pageDelayMs = Number.isInteger(pacing.delayMs) ? pacing.delayMs : 1250;
+        const maxMatches = Number.isInteger(pacing.maxMatches) && pacing.maxMatches >= 0 ? pacing.maxMatches : null;
+        const filters = {
+            startTime: options.startTime,
+            endTime: options.endTime,
+            queue: options.queue,
+            type: options.type,
+        };
+
+        let start = baseStart;
+        const allMatchIds = [];
+
+        while (true) {
+            const remaining = maxMatches === null ? 100 : Math.min(100, maxMatches - allMatchIds.length);
+            if (remaining <= 0) break;
+
+            const page = await this.getMatchlistByPuuid(puuid, { ...filters, start, count: remaining }, region);
+            allMatchIds.push(...page);
+
+            if (page.length < remaining) break;
+            start += page.length;
+            if (pageDelayMs > 0) await sleep(pageDelayMs);
+        }
+
+        return allMatchIds;
+    },
+
+    /**
+     * Fetch match IDs and full match payloads for each ID.
+     * @param {string} puuid - Player PUUID.
+     * @param {object} [options] - Riot filters: startTime, endTime, queue, type, start.
+     * @param {string} [region] - Region code used to resolve shard routing.
+     * @param {object} [pacing] - Pacing controls.
+     * @param {number} [pacing.pageDelayMs=1250] - Delay between matchlist page requests.
+     * @param {number} [pacing.detailDelayMs=1250] - Delay between match detail requests.
+     * @param {number|null} [pacing.maxMatches=null] - Optional cap on total matches fetched.
+     * @returns {Promise<{matchIds: string[], matches: object[]}>} IDs and full match payloads.
+     */
+    async getMatchesWithDetailsByPuuid(puuid, options = {}, region = defaultRegion, pacing = {}) {
+        const pageDelayMs = Number.isInteger(pacing.pageDelayMs) ? pacing.pageDelayMs : 1250;
+        const detailDelayMs = Number.isInteger(pacing.detailDelayMs) ? pacing.detailDelayMs : 1250;
+        const maxMatches = Number.isInteger(pacing.maxMatches) && pacing.maxMatches >= 0 ? pacing.maxMatches : null;
+        const matchIds = await this.getMatchlistByPuuidAll(
+            puuid,
+            options,
+            region,
+            { delayMs: pageDelayMs, maxMatches }
+        );
+        const matches = [];
+
+        for (let i = 0; i < matchIds.length; i += 1) {
+            matches.push(await this.getMatchById(matchIds[i], region));
+            if (detailDelayMs > 0 && i < matchIds.length - 1) {
+                await sleep(detailDelayMs);
+            }
+        }
+
+        return { matchIds, matches };
+    },
+});

package/index.js

@@ -1,41 +1,42 @@
 require('dotenv').config();
 const axios = require('axios');
+const riotEndpoints = require('./endpoints/riot');
+const dataDragonEndpoints = require('./endpoints/datadragon');
+
+// Maps region codes to the platform and routing shard hosts required by Riot APIs.
+const regionMap = {
+    BR1: { platform: 'br1.api.riotgames.com', shard: 'americas.api.riotgames.com' },
+    EUN1: { platform: 'eun1.api.riotgames.com', shard: 'europe.api.riotgames.com' },
+    EUW1: { platform: 'euw1.api.riotgames.com', shard: 'europe.api.riotgames.com' },
+    JP1: { platform: 'jp1.api.riotgames.com', shard: 'asia.api.riotgames.com' },
+    KR: { platform: 'kr.api.riotgames.com', shard: 'asia.api.riotgames.com' },
+    LA1: { platform: 'la1.api.riotgames.com', shard: 'americas.api.riotgames.com' },
+    LA2: { platform: 'la2.api.riotgames.com', shard: 'americas.api.riotgames.com' },
+    NA1: { platform: 'na1.api.riotgames.com', shard: 'americas.api.riotgames.com' },
+    OC1: { platform: 'oc1.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    TR1: { platform: 'tr1.api.riotgames.com', shard: 'europe.api.riotgames.com' },
+    RU: { platform: 'ru.api.riotgames.com', shard: 'europe.api.riotgames.com' },
+    PH2: { platform: 'ph2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    SG2: { platform: 'sg2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    TH2: { platform: 'th2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    TW2: { platform: 'tw2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+    VN2: { platform: 'vn2.api.riotgames.com', shard: 'sea.api.riotgames.com' },
+};
 
-/**
- * RiotAPI class for interacting with Riot Games API endpoints.
- */
 class RiotAPI {
     constructor() {
         this.apiKey = process.env.RIOT_API_KEY;
         if (!this.apiKey) throw new Error('RIOT_API_KEY is required in .env');
-        this.region = process.env.REGION || 'euw1';
+        this.region = (process.env.REGION || 'EUW1').toUpperCase();
+        if (!regionMap[this.region]) throw new Error(`Invalid region: ${this.region}`);
         this.client = axios.create({
-            baseURL: `https://${this.region}.api.riotgames.com`,
             headers: { 'X-Riot-Token': this.apiKey },
         });
+        // Attach endpoint methods with a shared axios client and region configuration.
+        Object.assign(this, riotEndpoints(this.client, this.region, regionMap));
     }
 
-    /**
-     * Get summoner data by name.
-     * @param {string} name - Summoner name.
-     * @param {string} [region] - Region (defaults to constructor region).
-     * @returns {Promise<object>} Summoner data.
-     */
-    async getSummonerByName(name, region = this.region) {
-        try {
-            const response = await this.client.get(`/lol/summoner/v4/summoners/by-name/${encodeURIComponent(name)}`, {
-                baseURL: `https://${region}.api.riotgames.com`,
-            });
-            return response.data;
-        } catch (error) {
-            throw this._handleError(error);
-        }
-    }
-
-    /**
-     * Handle axios errors and provide meaningful messages.
-     * @private
-     */
+    // Normalize axios errors to stable Error messages for consumers.
     _handleError(error) {
         if (error.response) {
             const { status, data } = error.response;
@@ -47,28 +48,41 @@ class RiotAPI {
     }
 }
 
-/**
- * DataDragon class for accessing static game data.
- */
 class DataDragon {
-    constructor(version = '14.19.1', locale = 'en_US') {
+    constructor(version = null, locale = 'en_US') {
         this.version = version;
         this.locale = locale;
-        this.baseURL = `https://ddragon.leagueoflegends.com/cdn/${this.version}/data/${this.locale}`;
+        this.baseURL = null;
+        this._baseURLPromise = null;
+
+        // Attach static-data endpoint methods that resolve the latest version when needed.
+        Object.assign(this, dataDragonEndpoints(() => this._resolveBaseURL()));
     }
 
-    /**
-     * Get all champion data.
-     * @returns {Promise<object>} Champion data.
-     */
-    async getChampions() {
+    async _resolveBaseURL() {
+        if (this.baseURL) return this.baseURL;
+        if (this._baseURLPromise) return this._baseURLPromise;
+
+        this._baseURLPromise = (async () => {
+            if (!this.version) {
+                const response = await axios.get('https://ddragon.leagueoflegends.com/api/versions.json');
+                const latestVersion = Array.isArray(response.data) ? response.data[0] : null;
+                if (!latestVersion) {
+                    throw new Error('Could not resolve latest Data Dragon version');
+                }
+                this.version = latestVersion;
+            }
+
+            this.baseURL = `https://ddragon.leagueoflegends.com/cdn/${this.version}/data/${this.locale}`;
+            return this.baseURL;
+        })();
+
         try {
-            const response = await axios.get(`${this.baseURL}/champion.json`);
-            return response.data;
-        } catch (error) {
-            throw new Error(`DataDragon error: ${error.message}`);
+            return await this._baseURLPromise;
+        } finally {
+            this._baseURLPromise = null;
         }
     }
 }
 
-module.exports = { RiotAPI, DataDragon };
+module.exports = { RiotAPI, DataDragon };

package/package.json

@@ -1,14 +1,27 @@
 {
   "name": "@timmsy/riftjs",
-  "version": "1.0.0",
+  "version": "2.0.1",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "npm run test:endpoints",
+    "test:endpoints": "node test-endpoints.js"
   },
   "dependencies": {
     "axios": "^1.7.7",
     "dotenv": "^16.4.5"
   },
+  "keywords": [
+    "riot-api",
+    "league-of-legends",
+    "lol-api",
+    "datadragon",
+    "summoner",
+    "match-history",
+    "game-data",
+    "node-js",
+    "javascript",
+    "api-wrapper"
+  ],
   "author": "James Timms",
   "description": "A lightweight Node.js wrapper for the Riot Games API, providing easy access to League of Legends game data.",
   "license": "MIT",

package/test-endpoints.js

@@ -0,0 +1,65 @@
+require('dotenv').config();
+const { RiotAPI, DataDragon } = require('./index');
+
+async function run() {
+    const riotId = process.env.TEST_RIOT_ID;
+    const tagLine = process.env.TEST_TAG_LINE;
+    const dd = new DataDragon();
+
+    if (process.env.RIOT_API_KEY && riotId) {
+        const riot = new RiotAPI();
+        const account = await riot.getAccountByRiotId(riotId, tagLine);
+        console.log('[PASS] getAccountByRiotId:', account.puuid);
+
+        const summoner = await riot.getSummonerByPuuid(account.puuid);
+        console.log('[PASS] getSummonerByPuuid:', {
+            puuid: summoner.puuid,
+            summonerLevel: summoner.summonerLevel,
+        });
+
+        const matchIds = await riot.getMatchlistByPuuid(account.puuid, { start: 0, count: 3 });
+        console.log('[PASS] getMatchlistByPuuid:', matchIds.length, 'match ids');
+
+        if (matchIds.length > 0) {
+            const match = await riot.getMatchById(matchIds[0]);
+            console.log('[PASS] getMatchById:', match.metadata.matchId);
+
+            const timeline = await riot.getMatchTimelineById(matchIds[0]);
+            console.log('[PASS] getMatchTimelineById:', timeline.metadata.matchId);
+
+            const allMatchIds = await riot.getMatchlistByPuuidAll(
+                account.puuid,
+                { start: 0 },
+                undefined,
+                { maxMatches: 2, delayMs: 0 }
+            );
+            console.log('[PASS] getMatchlistByPuuidAll:', allMatchIds.length, 'match ids');
+
+            const withDetails = await riot.getMatchesWithDetailsByPuuid(
+                account.puuid,
+                { start: 0 },
+                undefined,
+                { maxMatches: 2, pageDelayMs: 0, detailDelayMs: 0 }
+            );
+            console.log('[PASS] getMatchesWithDetailsByPuuid:', withDetails.matches.length, 'matches');
+        } else {
+            console.log('[SKIP] Match-by-id/timeline/all/details checks: no matches returned');
+        }
+    } else if (process.env.RIOT_API_KEY) {
+        console.log('[SKIP] Riot endpoints: set TEST_RIOT_ID (and TEST_TAG_LINE if needed)');
+    } else {
+        console.log('[SKIP] Riot endpoints: set RIOT_API_KEY and TEST_RIOT_ID');
+    }
+
+    const champions = await dd.getChampions();
+    console.log('[PASS] getChampions:', Object.keys(champions.data || {}).length, 'champions');
+    console.log('[INFO] DataDragon version:', dd.version);
+
+    const items = await dd.getItems();
+    console.log('[PASS] getItems:', Object.keys(items.data || {}).length, 'items');
+}
+
+run().catch((error) => {
+    console.error('[FAIL]', error.message);
+    process.exitCode = 1;
+});