irdata_js 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 popmonkey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# irdata_js
+
+JavaScript library to interact with the iRacing /data API.
+
+## Installation
+
+```bash
+npm install irdata_js
+```
+
+## Quick Start
+
+The library supports OAuth 2.0 authentication.
+
+### 1. Initialize the Client
+
+```javascript
+import { IRacingClient } from 'irdata_js';
+
+const client = new IRacingClient({
+  auth: {
+    clientId: 'YOUR_CLIENT_ID', // Required for OAuth
+    redirectUri: 'YOUR_REDIRECT_URI', // Required for OAuth
+  },
+});
+```
+
+### 2. Authentication
+
+#### Web / Browser (OAuth 2.0 PKCE)
+
+To authenticate in the browser, you need to generate an authorization URL, redirect the user, and then handle the callback.
+
+**Step 1: Generate Auth URL and Redirect**
+
+```javascript
+const url = await client.auth.generateAuthUrl();
+window.location.href = url;
+```
+
+**Step 2: Handle Callback**
+
+On your redirect page, capture the `code` from the URL:
+
+```javascript
+const params = new URLSearchParams(window.location.search);
+const code = params.get('code');
+
+if (code) {
+  await client.auth.handleCallback(code);
+  // Success! The client is now authenticated with an access token.
+}
+```
+
+### 3. Fetch Data
+
+Once authenticated, you can call any endpoint using `getData`. This method handles authentication headers and automatically follows S3 links if returned by the API.
+
+```javascript
+try {
+  // Call an endpoint directly
+  const memberInfo = await client.getData('/member/info');
+  console.log(memberInfo);
+} catch (error) {
+  console.error('Failed to fetch member info:', error);
+}
+```
+
+## Development
+
+### Build
+
+```bash
+npm run build
+```
+
+### Manual Verification (OAuth Flow)
+
+This repository includes a local development proxy server to test the OAuth flow and API interaction, avoiding CORS issues during development.
+
+1.  Create a file named `auth_config.json` in the `examples/` directory (ignored by git) with your credentials:
+
+    ```json
+    {
+      "clientId": "YOUR_CLIENT_ID",
+      "redirectUri": "http://127.0.0.1/irdata_js/callback",
+      "tokenEndpoint": "http://127.0.0.1/token"
+    }
+    ```
+
+    _Note: The `redirectUri` should match what you registered with iRacing. The proxy server is configured to intercept the path specified in `redirectUri` (e.g. `/irdata_js/callback`) and redirect it to the example app while preserving the auth code._
+
+2.  Start the proxy server:
+
+    ```bash
+    npm run dev
+    ```
+
+    _This starts the proxy server on port 80. Depending on your system configuration, you might need elevated privileges (e.g., `sudo`) to listen on port 80._
+
+3.  Open `http://127.0.0.1/examples/index.html` in your browser.
+    - The `index.html` is configured to use the local proxy endpoints (`/token`, `/data`, `/passthrough`) to bypass CORS restrictions enforced by the browser.
+
+## License
+
+ISC

package/dist/auth/AuthManager.d.ts

@@ -0,0 +1,25 @@
+interface AuthConfig {
+    clientId?: string;
+    redirectUri?: string;
+    authBaseUrl?: string;
+    tokenEndpoint?: string;
+}
+export interface TokenStore {
+    getAccessToken(): string | null;
+    setAccessToken(token: string): void;
+    getRefreshToken(): string | null;
+    setRefreshToken(token: string): void;
+    clear(): void;
+}
+export declare class AuthManager {
+    private tokenStore;
+    private config;
+    private baseUrl;
+    constructor(config?: AuthConfig);
+    get accessToken(): string | null;
+    getAuthHeaders(): HeadersInit;
+    generateAuthUrl(): Promise<string>;
+    handleCallback(code: string): Promise<void>;
+    refreshAccessToken(): Promise<boolean>;
+}
+export {};

package/dist/auth/AuthManager.js

@@ -0,0 +1,170 @@
+import { PKCEHelper } from './PKCEHelper.js';
+import { IRacingAPIError } from '../errors.js';
+class InMemoryTokenStore {
+    accessToken = null;
+    refreshToken = null;
+    getAccessToken() {
+        return this.accessToken;
+    }
+    setAccessToken(token) {
+        this.accessToken = token;
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    setRefreshToken(token) {
+        this.refreshToken = token;
+    }
+    clear() {
+        this.accessToken = null;
+        this.refreshToken = null;
+    }
+}
+class LocalStorageTokenStore {
+    prefix = 'irdata_';
+    getAccessToken() {
+        return localStorage.getItem(this.prefix + 'access_token');
+    }
+    setAccessToken(token) {
+        localStorage.setItem(this.prefix + 'access_token', token);
+    }
+    getRefreshToken() {
+        return localStorage.getItem(this.prefix + 'refresh_token');
+    }
+    setRefreshToken(token) {
+        localStorage.setItem(this.prefix + 'refresh_token', token);
+    }
+    clear() {
+        localStorage.removeItem(this.prefix + 'access_token');
+        localStorage.removeItem(this.prefix + 'refresh_token');
+    }
+}
+export class AuthManager {
+    tokenStore;
+    config;
+    baseUrl = 'https://oauth.iracing.com/oauth2';
+    constructor(config = {}) {
+        this.config = config;
+        this.baseUrl = config.authBaseUrl || 'https://oauth.iracing.com/oauth2';
+        if (typeof window !== 'undefined' && window.localStorage) {
+            this.tokenStore = new LocalStorageTokenStore();
+        }
+        else {
+            this.tokenStore = new InMemoryTokenStore();
+        }
+    }
+    get accessToken() {
+        return this.tokenStore.getAccessToken();
+    }
+    getAuthHeaders() {
+        const headers = {};
+        const token = this.tokenStore.getAccessToken();
+        if (token) {
+            // OAuth2 Bearer Token
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        return headers;
+    }
+    // --- Browser OAuth2 PKCE ---
+    async generateAuthUrl() {
+        if (!this.config.clientId || !this.config.redirectUri) {
+            throw new Error('clientId and redirectUri required for OAuth');
+        }
+        const verifier = PKCEHelper.generateVerifier();
+        const challenge = await PKCEHelper.generateChallenge(verifier);
+        // Store verifier for the callback
+        if (typeof window !== 'undefined' && window.sessionStorage) {
+            window.sessionStorage.setItem('irdata_pkce_verifier', verifier);
+        }
+        const params = new URLSearchParams({
+            response_type: 'code',
+            client_id: this.config.clientId,
+            redirect_uri: this.config.redirectUri,
+            scope: 'iracing.auth', // Required based iRacing docs
+            code_challenge: challenge,
+            code_challenge_method: 'S256',
+        });
+        return `${this.baseUrl}/authorize?${params.toString()}`;
+    }
+    async handleCallback(code) {
+        let verifier = '';
+        if (typeof window !== 'undefined' && window.sessionStorage) {
+            verifier = window.sessionStorage.getItem('irdata_pkce_verifier') || '';
+            window.sessionStorage.removeItem('irdata_pkce_verifier');
+        }
+        if (!verifier) {
+            throw new Error('No PKCE verifier found');
+        }
+        const body = new URLSearchParams({
+            grant_type: 'authorization_code',
+            client_id: this.config.clientId,
+            redirect_uri: this.config.redirectUri,
+            code: code,
+            code_verifier: verifier,
+        });
+        const tokenUrl = this.config.tokenEndpoint || `${this.baseUrl}/token`;
+        const response = await fetch(tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: body.toString(),
+        });
+        if (!response.ok) {
+            let errorBody;
+            try {
+                errorBody = await response.json();
+            }
+            catch (_e) {
+                try {
+                    errorBody = await response.text();
+                }
+                catch (_e2) {
+                    /* ignore */
+                }
+            }
+            throw new IRacingAPIError(`Failed to exchange code for token: ${response.status} ${response.statusText}`, response.status, response.statusText, errorBody);
+        }
+        const tokens = await response.json();
+        this.tokenStore.setAccessToken(tokens.access_token);
+        if (tokens.refresh_token) {
+            this.tokenStore.setRefreshToken(tokens.refresh_token);
+        }
+    }
+    async refreshAccessToken() {
+        const refreshToken = this.tokenStore.getRefreshToken();
+        if (!refreshToken) {
+            return false;
+        }
+        if (!this.config.clientId) {
+            throw new Error('clientId required for token refresh');
+        }
+        const body = new URLSearchParams({
+            grant_type: 'refresh_token',
+            client_id: this.config.clientId,
+            refresh_token: refreshToken,
+        });
+        const tokenUrl = this.config.tokenEndpoint || `${this.baseUrl}/token`;
+        try {
+            const response = await fetch(tokenUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: body.toString(),
+            });
+            if (!response.ok) {
+                // If refresh fails (e.g. token expired), clear tokens to force re-login
+                this.tokenStore.clear();
+                return false;
+            }
+            const tokens = await response.json();
+            this.tokenStore.setAccessToken(tokens.access_token);
+            // Update refresh token if a new one is returned
+            if (tokens.refresh_token) {
+                this.tokenStore.setRefreshToken(tokens.refresh_token);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Error refreshing token:', error);
+            return false;
+        }
+    }
+}

package/dist/auth/PKCEHelper.d.ts

@@ -0,0 +1,14 @@
+export declare class PKCEHelper {
+    /**
+     * Generates a random string for the code verifier.
+     * @param length Length of the string (43-128 characters recommended)
+     */
+    static generateVerifier(length?: number): string;
+    /**
+     * Generates the code challenge from the verifier using SHA-256.
+     * @param verifier The code verifier string
+     */
+    static generateChallenge(verifier: string): Promise<string>;
+    private static base64URLEncode;
+    private static sha256;
+}

package/dist/auth/PKCEHelper.js

@@ -0,0 +1,131 @@
+export class PKCEHelper {
+    /**
+     * Generates a random string for the code verifier.
+     * @param length Length of the string (43-128 characters recommended)
+     */
+    static generateVerifier(length = 128) {
+        const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';
+        let result = '';
+        if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+            const values = new Uint8Array(length);
+            crypto.getRandomValues(values);
+            for (let i = 0; i < length; i++) {
+                result += charset[values[i] % charset.length];
+            }
+        }
+        else {
+            // Fallback for environments without crypto.getRandomValues (though Node 18+ and browsers have it)
+            for (let i = 0; i < length; i++) {
+                result += charset.charAt(Math.floor(Math.random() * charset.length));
+            }
+        }
+        return result;
+    }
+    /**
+     * Generates the code challenge from the verifier using SHA-256.
+     * @param verifier The code verifier string
+     */
+    static async generateChallenge(verifier) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(verifier);
+        if (typeof crypto !== 'undefined' && crypto.subtle) {
+            const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+            return this.base64URLEncode(hashBuffer);
+        }
+        else {
+            // Fallback for insecure contexts or environments without crypto.subtle
+            const hashBuffer = this.sha256(data);
+            return this.base64URLEncode(hashBuffer);
+        }
+    }
+    static base64URLEncode(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        const base64 = btoa(binary);
+        return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    }
+    static sha256(data) {
+        const K = [
+            0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4,
+            0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe,
+            0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f,
+            0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+            0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
+            0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+            0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116,
+            0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+            0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
+            0xc67178f2,
+        ];
+        function rotr(n, x) {
+            return (x >>> n) | (x << (32 - n));
+        }
+        function ch(x, y, z) {
+            return (x & y) ^ (~x & z);
+        }
+        function maj(x, y, z) {
+            return (x & y) ^ (x & z) ^ (y & z);
+        }
+        function sigma0(x) {
+            return rotr(2, x) ^ rotr(13, x) ^ rotr(22, x);
+        }
+        function sigma1(x) {
+            return rotr(6, x) ^ rotr(11, x) ^ rotr(25, x);
+        }
+        function gamma0(x) {
+            return rotr(7, x) ^ rotr(18, x) ^ (x >>> 3);
+        }
+        function gamma1(x) {
+            return rotr(17, x) ^ rotr(19, x) ^ (x >>> 10);
+        }
+        const bytes = new Uint8Array(data);
+        const len = bytes.length * 8;
+        // Padding
+        const paddingLen = (((len + 64) >>> 9) << 4) + 16;
+        const words = new Uint32Array(paddingLen);
+        for (let i = 0; i < bytes.length; i++)
+            words[i >>> 2] |= bytes[i] << (24 - (i % 4) * 8);
+        words[bytes.length >>> 2] |= 0x80 << (24 - (bytes.length % 4) * 8);
+        words[paddingLen - 1] = len;
+        const H = [
+            0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
+            0x5be0cd19,
+        ];
+        const W = new Uint32Array(64);
+        for (let i = 0; i < words.length; i += 16) {
+            W.fill(0);
+            for (let j = 0; j < 16; j++)
+                W[j] = words[i + j];
+            for (let j = 16; j < 64; j++)
+                W[j] = (gamma1(W[j - 2]) + W[j - 7] + gamma0(W[j - 15]) + W[j - 16]) | 0;
+            let [a, b, c, d, e, f, g, h] = H;
+            for (let j = 0; j < 64; j++) {
+                const T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0;
+                const T2 = (sigma0(a) + maj(a, b, c)) | 0;
+                h = g;
+                g = f;
+                f = e;
+                e = (d + T1) | 0;
+                d = c;
+                c = b;
+                b = a;
+                a = (T1 + T2) | 0;
+            }
+            H[0] = (H[0] + a) | 0;
+            H[1] = (H[1] + b) | 0;
+            H[2] = (H[2] + c) | 0;
+            H[3] = (H[3] + d) | 0;
+            H[4] = (H[4] + e) | 0;
+            H[5] = (H[5] + f) | 0;
+            H[6] = (H[6] + g) | 0;
+            H[7] = (H[7] + h) | 0;
+        }
+        const buffer = new ArrayBuffer(32);
+        const view = new DataView(buffer);
+        H.forEach((h, i) => view.setUint32(i * 4, h, false));
+        return buffer;
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,28 @@
+import { AuthManager } from './auth/AuthManager.js';
+interface ClientConfig {
+    apiUrl?: string;
+    fileProxyUrl?: string;
+    auth?: {
+        clientId?: string;
+        redirectUri?: string;
+        authBaseUrl?: string;
+        tokenEndpoint?: string;
+    };
+}
+export declare class IRacingClient {
+    auth: AuthManager;
+    private apiUrl;
+    private fileProxyUrl?;
+    constructor(config?: ClientConfig);
+    /**
+     * Performs a fetch request with authentication headers.
+     * Does NOT automatically follow "link" responses.
+     */
+    request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+    private handleErrorResponse;
+    /**
+     * Fetches data from an endpoint, automatically following any S3 links returned.
+     */
+    getData<T>(endpoint: string): Promise<T>;
+}
+export {};

package/dist/client.js

@@ -0,0 +1,109 @@
+import { AuthManager } from './auth/AuthManager.js';
+import { IRacingAPIError } from './errors.js';
+export class IRacingClient {
+    auth;
+    apiUrl;
+    fileProxyUrl;
+    constructor(config = {}) {
+        this.apiUrl = config.apiUrl || 'https://members-ng.iracing.com/data';
+        this.fileProxyUrl = config.fileProxyUrl;
+        this.auth = new AuthManager(config.auth);
+    }
+    /**
+     * Performs a fetch request with authentication headers.
+     * Does NOT automatically follow "link" responses.
+     */
+    async request(endpoint, options = {}) {
+        // Remove leading slash from endpoint if present to avoid double slashes if apiUrl has trailing slash
+        const cleanEndpoint = endpoint.startsWith('/') ? endpoint.substring(1) : endpoint;
+        const cleanApiUrl = this.apiUrl.endsWith('/') ? this.apiUrl : `${this.apiUrl}/`;
+        const url = `${cleanApiUrl}${cleanEndpoint}`;
+        const headers = this.auth.getAuthHeaders();
+        const mergedOptions = {
+            ...options,
+            headers: {
+                ...headers,
+                ...options.headers,
+                'Content-Type': 'application/json',
+            },
+        };
+        const response = await fetch(url, mergedOptions);
+        if (!response.ok) {
+            if (response.status === 401) {
+                // Try to refresh token
+                try {
+                    const refreshed = await this.auth.refreshAccessToken();
+                    if (refreshed) {
+                        // Retry request with new token
+                        const newHeaders = this.auth.getAuthHeaders();
+                        const retryOptions = {
+                            ...options,
+                            headers: {
+                                ...newHeaders,
+                                ...options.headers,
+                                'Content-Type': 'application/json',
+                            },
+                        };
+                        const retryResponse = await fetch(url, retryOptions);
+                        if (retryResponse.ok) {
+                            return retryResponse.json();
+                        }
+                        // If retry fails, use the retryResponse for error handling below
+                        return this.handleErrorResponse(retryResponse);
+                    }
+                }
+                catch (refreshError) {
+                    console.error('Token refresh failed during request retry:', refreshError);
+                    // Fall through to original 401 error handling
+                }
+            }
+            return this.handleErrorResponse(response);
+        }
+        return response.json();
+    }
+    async handleErrorResponse(response) {
+        let body;
+        const contentType = response.headers.get('content-type');
+        try {
+            if (contentType && contentType.includes('application/json')) {
+                body = await response.json();
+            }
+            else {
+                body = await response.text();
+            }
+        }
+        catch (_e) {
+            // ignore
+        }
+        throw new IRacingAPIError(`API Request failed: ${response.status} ${response.statusText}`, response.status, response.statusText, body);
+    }
+    /**
+     * Fetches data from an endpoint, automatically following any S3 links returned.
+     */
+    async getData(endpoint) {
+        const data = await this.request(endpoint);
+        // Check if the response contains a generic link to S3 and follow it
+        if (data &&
+            typeof data === 'object' &&
+            'link' in data &&
+            typeof data.link === 'string') {
+            const s3Link = data.link;
+            if (s3Link.startsWith('http')) {
+                // Fetch the S3 link without original auth headers
+                let fetchUrl = s3Link;
+                if (this.fileProxyUrl) {
+                    // If a file proxy is configured, use it
+                    // e.g. http://localhost:80/passthrough?url=...
+                    const separator = this.fileProxyUrl.includes('?') ? '&' : '?';
+                    fetchUrl = `${this.fileProxyUrl}${separator}url=${encodeURIComponent(s3Link)}`;
+                }
+                const linkResponse = await fetch(fetchUrl);
+                if (!linkResponse.ok) {
+                    return this.handleErrorResponse(linkResponse);
+                }
+                return linkResponse.json();
+            }
+        }
+        return data;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class IRacingAPIError extends Error {
+    status: number;
+    statusText: string;
+    body?: unknown | undefined;
+    constructor(message: string, status: number, statusText: string, body?: unknown | undefined);
+}

package/dist/errors.js

@@ -0,0 +1,12 @@
+export class IRacingAPIError extends Error {
+    status;
+    statusText;
+    body;
+    constructor(message, status, statusText, body) {
+        super(message);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = 'IRacingAPIError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './client.js';
+export * from './auth/AuthManager.js';
+export * from './auth/PKCEHelper.js';
+export * from './errors.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './client.js';
+export * from './auth/AuthManager.js';
+export * from './auth/PKCEHelper.js';
+export * from './errors.js';

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "irdata_js",
+  "version": "0.1.0",
+  "description": "JavaScript library to interact with the iRacing /data API",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "build": "tsc",
+    "dev": "node proxy_server.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/popmonkey/irdata_js.git"
+  },
+  "keywords": [
+    "iracing",
+    "api",
+    "data",
+    "sdk"
+  ],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/popmonkey/irdata_js/issues"
+  },
+  "homepage": "https://github.com/popmonkey/irdata_js#readme",
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.1",
+    "@typescript-eslint/parser": "^8.53.1",
+    "cors": "^2.8.5",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "express": "^5.2.1",
+    "globals": "^17.0.0",
+    "happy-dom": "^20.1.0",
+    "prettier": "^3.8.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.53.1",
+    "vitest": "^3.2.4"
+  }
+}