keeperboard 1.0.4 → 2.0.1

package/README.md

@@ -1,8 +1,6 @@
 # KeeperBoard SDK
 
-TypeScript client SDK for [KeeperBoard](https://github.com/clauderoy790/keeperboard) — a free, open-source leaderboard-as-a-service for indie game developers.
-
-Works with Phaser.js, vanilla JavaScript, and any TypeScript/JavaScript game running in the browser.
+TypeScript client for [KeeperBoard](https://keeperboard.vercel.app) leaderboard-as-a-service. Works in browsers and Node.js.
 
 ## Installation
 
@@ -10,287 +8,222 @@ Works with Phaser.js, vanilla JavaScript, and any TypeScript/JavaScript game run
 npm install keeperboard
 ```
 
-### Alternative: Copy source directly
-
-If you prefer not to use npm, copy the `src/` folder into your project:
-
-```typescript
-import { KeeperBoardClient, PlayerIdentity } from './keeperboard/index';
-```
-
-## Quick Start
-
-### 1. Get your API key
-
-1. Sign up at your KeeperBoard dashboard
-2. Create a game
-3. Create an environment (dev/prod)
-4. Generate an API key for that environment
-
-### 2. Initialize the client
+## Quick Start (15 lines)
 
 ```typescript
-import { KeeperBoardClient, PlayerIdentity } from 'keeperboard';
+import { KeeperBoardSession } from 'keeperboard';
 
-// Create the API client
-const client = new KeeperBoardClient({
-  apiKey: 'kb_prod_your_api_key_here',
+const session = new KeeperBoardSession({
+  apiKey: 'kb_dev_your_api_key',
+  leaderboard: 'main',
+  cache: { ttlMs: 30000 },  // Optional: 30s cache
+  retry: { maxAgeMs: 86400000 },  // Optional: 24h retry queue
 });
 
-// Helper for persistent player identity
-const identity = new PlayerIdentity();
-```
-
-### 3. Submit a score
-
-```typescript
-const playerGuid = identity.getOrCreatePlayerGuid();
-
-// Submit to default leaderboard
-const result = await client.submitScore(playerGuid, 'PlayerName', 1500);
-
-console.log(`Rank: #${result.rank}`);
-console.log(`New high score: ${result.is_new_high_score}`);
-```
-
-### 4. Display the leaderboard
-
-```typescript
-// Get top 10
-const leaderboard = await client.getLeaderboard();
-
-leaderboard.entries.forEach((entry) => {
-  console.log(`#${entry.rank} ${entry.player_name}: ${entry.score}`);
-});
-```
-
-### 5. Show player's rank (even if not in top 10)
-
-```typescript
-const player = await client.getPlayerRank(playerGuid);
-
-if (player && player.rank > 10) {
-  console.log(`You are ranked #${player.rank} with ${player.score} points`);
+// Submit a score
+const result = await session.submitScore(1500);
+if (result.success) {
+  console.log(`Rank #${result.rank}, New high: ${result.isNewHighScore}`);
 }
-```
 
-## API Reference
-
-### KeeperBoardClient
-
-#### Constructor
-
-```typescript
-const client = new KeeperBoardClient({
-  apiKey: string, // API key from dashboard
+// Get leaderboard with player's rank
+const snapshot = await session.getSnapshot({ limit: 10 });
+snapshot.entries.forEach(e => {
+  console.log(`#${e.rank} ${e.playerName}: ${e.score}`, e.isCurrentPlayer ? '(you)' : '');
 });
 ```
 
-> **Note:** The API key determines which game and environment you're accessing. You don't need to pass environment or game IDs — they're implicit in the key.
-
----
-
-### Score Submission
-
-#### `submitScore(playerGuid, playerName, score)`
+## Two API Layers
 
-Submit a score to the default leaderboard. Only updates if higher than existing score.
+| Layer | Use case | Identity | Cache | Retry |
+|-------|----------|----------|-------|-------|
+| **KeeperBoardSession** | Browser games | Auto-managed | Built-in | Built-in |
+| **KeeperBoardClient** | Server-side, advanced | Manual | No | No |
 
-```typescript
-const result = await client.submitScore('player-uuid', 'PlayerName', 2500);
-// Returns: { id, player_guid, player_name, score, rank, is_new_high_score }
-```
-
-#### `submitScore(playerGuid, playerName, score, leaderboard)`
+Most browser games should use `KeeperBoardSession`. Use `KeeperBoardClient` for server-side code or when you need full control.
 
-Submit to a specific leaderboard by name.
-
-```typescript
-await client.submitScore('player-uuid', 'PlayerName', 2500, 'Weekly Best');
-```
+---
 
-#### `submitScore(playerGuid, playerName, score, leaderboard, metadata)`
+## KeeperBoardSession API
 
-Submit with optional metadata.
+### Constructor
 
 ```typescript
-await client.submitScore('player-uuid', 'PlayerName', 2500, 'Weekly Best', {
-  level: 10,
-  character: 'warrior',
+const session = new KeeperBoardSession({
+  apiKey: 'kb_dev_xxx',           // Required
+  leaderboard: 'main',            // Required - session is bound to one board
+  defaultPlayerName: 'ANON',      // Optional (default: 'ANON')
+  identity: { keyPrefix: 'app_' }, // Optional localStorage prefix
+  cache: { ttlMs: 30000 },        // Optional TTL cache for getSnapshot()
+  retry: { maxAgeMs: 86400000 },  // Optional retry queue for failed submissions
 });
 ```
 
----
-
-### Leaderboard
-
-#### `getLeaderboard()`
-
-Get the default leaderboard (top 10 entries).
+### Identity (auto-managed)
 
 ```typescript
-const lb = await client.getLeaderboard();
-// Returns: { entries, total_count, reset_schedule }
-```
-
-#### `getLeaderboard(name)`
+session.getPlayerGuid();     // Get or create persistent GUID
+session.getPlayerName();     // Get stored name or default
+session.setPlayerName(name); // Store name locally (doesn't update server)
 
-Get a specific leaderboard by name.
-
-```typescript
-const lb = await client.getLeaderboard('Weekly Best');
+// Validate a name (pure function)
+const validated = session.validateName('  Ace Pilot! ');
+// Returns 'ACEPILOT' or null if invalid
 ```
 
-#### `getLeaderboard(name, limit)`
-
-Get with a custom limit (max 100).
+### Core Methods
 
 ```typescript
-const lb = await client.getLeaderboard('Weekly Best', 50);
+// Submit score (identity auto-injected)
+const result = await session.submitScore(1500, { level: 5 });
+// Returns: { success: true, rank: 3, isNewHighScore: true }
+//      or: { success: false, error: 'Network error' }
+
+// Get snapshot (leaderboard + player rank combined)
+const snapshot = await session.getSnapshot({ limit: 10 });
+// Returns: {
+//   entries: [{ rank, playerGuid, playerName, score, isCurrentPlayer }],
+//   totalCount: 150,
+//   playerRank: { rank: 42, score: 1200, ... } | null  // Only if outside top N
+// }
+
+// Update player name on server
+const success = await session.updatePlayerName('MAVERICK');
 ```
 
-#### `getLeaderboard(name, limit, offset)`
-
-Get with pagination.
+### Retry Queue
 
 ```typescript
-// Page 2 (entries 11-20)
-const lb = await client.getLeaderboard('Weekly Best', 10, 10);
+// Check for pending scores from previous failed submissions
+if (session.hasPendingScore()) {
+  await session.retryPendingScore();
+}
 ```
 
----
-
-### Leaderboard Versions (Time-Based)
-
-For leaderboards with reset schedules (daily/weekly/monthly), you can query historical versions.
-
-#### `getLeaderboardVersion(name, version)`
-
-Get a specific version of a time-based leaderboard.
+### Cache
 
 ```typescript
-// Get last week's scores (version 3)
-const lastWeek = await client.getLeaderboardVersion('Weekly Best', 3);
-```
+// Pre-fetch in background (e.g., on menu load)
+session.prefetch();
 
-#### `getLeaderboardVersion(name, version, limit, offset)`
-
-Get historical version with pagination.
-
-```typescript
-const lb = await client.getLeaderboardVersion('Weekly Best', 3, 25, 0);
+// getSnapshot() automatically uses cache when fresh
 ```
 
----
-
-### Player
-
-#### `getPlayerRank(playerGuid)`
-
-Get a player's rank and score. Returns `null` if player has no score.
+### Escape Hatch
 
 ```typescript
-const player = await client.getPlayerRank('player-uuid');
-
-if (player) {
-  console.log(`Rank: #${player.rank}, Score: ${player.score}`);
-}
+// Access underlying client for advanced operations
+const client = session.getClient();
+await client.claimScore({ playerGuid: '...', playerName: '...' });
 ```
 
-#### `getPlayerRank(playerGuid, leaderboard)`
-
-Get player's rank on a specific leaderboard.
+---
 
-```typescript
-const player = await client.getPlayerRank('player-uuid', 'Weekly Best');
-```
+## KeeperBoardClient API
 
-#### `updatePlayerName(playerGuid, newName)`
+Low-level client with options-object methods and camelCase responses.
 
-Update a player's display name.
+### Constructor
 
 ```typescript
-await client.updatePlayerName('player-uuid', 'NewPlayerName');
+const client = new KeeperBoardClient({
+  apiKey: 'kb_dev_xxx',
+  defaultLeaderboard: 'main',  // Optional - used when leaderboard not specified
+});
 ```
 
----
-
-### Claim (for migrated scores)
-
-#### `claimScore(playerGuid, playerName)`
-
-Claim a migrated score by matching player name. Used when scores were imported without player GUIDs.
+### Methods
 
 ```typescript
-const result = await client.claimScore('new-player-guid', 'ImportedPlayerName');
-console.log(`Claimed score: ${result.score}, Rank: #${result.rank}`);
-```
-
----
+// Submit score
+const result = await client.submitScore({
+  playerGuid: 'abc-123',
+  playerName: 'ACE',
+  score: 1500,
+  metadata: { level: 5 },      // Optional
+  leaderboard: 'weekly',       // Optional - overrides defaultLeaderboard
+});
+// Returns: ScoreResult { id, playerGuid, playerName, score, rank, isNewHighScore }
+
+// Get leaderboard
+const lb = await client.getLeaderboard({
+  leaderboard: 'main',  // Optional
+  limit: 25,            // Optional (default 10, max 100)
+  offset: 0,            // Optional pagination
+  version: 3,           // Optional - for time-based boards
+});
+// Returns: LeaderboardResult { entries, totalCount, resetSchedule, version?, ... }
 
-### Health Check
+// Get player rank
+const player = await client.getPlayerRank({
+  playerGuid: 'abc-123',
+  leaderboard: 'main',  // Optional
+});
+// Returns: PlayerResult | null
 
-#### `healthCheck()`
+// Update player name
+const updated = await client.updatePlayerName({
+  playerGuid: 'abc-123',
+  newName: 'MAVERICK',
+  leaderboard: 'main',  // Optional
+});
 
-Check if the API is healthy. Does not require an API key.
+// Claim migrated score (for imported data without GUIDs)
+const claim = await client.claimScore({
+  playerGuid: 'abc-123',
+  playerName: 'OldPlayer',
+  leaderboard: 'main',  // Optional
+});
 
-```typescript
+// Health check (no auth required)
 const health = await client.healthCheck();
-console.log(`API Version: ${health.version}`);
 ```
 
 ---
 
-### PlayerIdentity
+## Name Validation
 
-Helper for managing persistent player identity in localStorage.
+Standalone function for validating player names:
 
 ```typescript
-const identity = new PlayerIdentity({
-  keyPrefix: 'mygame_', // optional, default: 'keeperboard_'
+import { validateName } from 'keeperboard';
+
+validateName('  Ace Pilot! ');        // 'ACEPILOT'
+validateName('x');                     // null (too short)
+validateName('verylongname123456');   // 'VERYLONGNAME' (truncated to 12)
+
+// Custom options
+validateName('hello', {
+  minLength: 3,
+  maxLength: 8,
+  uppercase: false,
+  allowedPattern: /[^a-z]/g,
 });
-
-// Get or create a persistent player GUID
-const guid = identity.getOrCreatePlayerGuid();
-
-// Store/retrieve player name
-identity.setPlayerName('PlayerName');
-const name = identity.getPlayerName();
-
-// Check if identity exists
-if (identity.hasIdentity()) {
-  // returning player
-}
-
-// Clear identity (e.g., for "Sign Out")
-identity.clear();
 ```
 
 ---
 
-### Error Handling
-
-All methods throw `KeeperBoardError` on failure:
+## Error Handling
 
 ```typescript
 import { KeeperBoardError } from 'keeperboard';
 
 try {
-  await client.submitScore(playerGuid, name, score);
+  await client.submitScore({ ... });
 } catch (error) {
   if (error instanceof KeeperBoardError) {
-    console.error(`Error [${error.code}]: ${error.message}`);
-
     switch (error.code) {
       case 'INVALID_API_KEY':
-        // Check your API key
+        console.error('Check your API key');
         break;
       case 'NOT_FOUND':
-        // Player or leaderboard not found
+        console.error('Leaderboard not found');
         break;
       case 'INVALID_REQUEST':
-        // Check request parameters
+        console.error('Bad request:', error.message);
         break;
+      default:
+        console.error('API error:', error.message);
     }
   }
 }
@@ -298,129 +231,100 @@ try {
 
 ---
 
-## Multiple Leaderboards
-
-If your game has multiple leaderboards (e.g., per-level or per-mode):
-
-```typescript
-// Submit to different leaderboards
-await client.submitScore(guid, name, score, 'Level 1');
-await client.submitScore(guid, name, score, 'Endless Mode');
-await client.submitScore(guid, name, score, 'Weekly Challenge');
-
-// Get specific leaderboards
-const level1 = await client.getLeaderboard('Level 1');
-const endless = await client.getLeaderboard('Endless Mode', 50);
-```
-
----
-
-## Phaser.js Integration Example
+## Phaser.js Integration
 
 ```typescript
-import { KeeperBoardClient, PlayerIdentity } from 'keeperboard';
-
-const client = new KeeperBoardClient({
-  apiKey: 'kb_prod_your_api_key',
+import { KeeperBoardSession } from 'keeperboard';
+
+// Initialize once at game start
+const leaderboard = new KeeperBoardSession({
+  apiKey: import.meta.env.VITE_KEEPERBOARD_API_KEY,
+  leaderboard: 'main',
+  cache: { ttlMs: 30000 },
+  retry: { maxAgeMs: 86400000 },
 });
 
-const identity = new PlayerIdentity();
-
-class GameOverScene extends Phaser.Scene {
-  private score: number = 0;
-
-  init(data: { score: number }) {
-    this.score = data.score;
+// In BootScene - prefetch and retry
+class BootScene extends Phaser.Scene {
+  async create() {
+    leaderboard.prefetch();
+    await leaderboard.retryPendingScore();
+    this.scene.start('MenuScene');
   }
+}
 
+// In GameOverScene
+class GameOverScene extends Phaser.Scene {
   async create() {
-    const playerGuid = identity.getOrCreatePlayerGuid();
-    const playerName = identity.getPlayerName() ?? 'Anonymous';
-
-    // Submit score
-    const result = await client.submitScore(playerGuid, playerName, this.score);
-
-    // Display rank
-    this.add
-      .text(400, 200, `Your Rank: #${result.rank}`, { fontSize: '32px' })
-      .setOrigin(0.5);
-
-    if (result.is_new_high_score) {
-      this.add
-        .text(400, 250, 'NEW HIGH SCORE!', {
-          fontSize: '24px',
-          color: '#ffff00',
-        })
-        .setOrigin(0.5);
+    const result = await leaderboard.submitScore(this.score);
+    if (result.success) {
+      this.showRank(result.rank, result.isNewHighScore);
     }
 
-    // Display top 10
-    const leaderboard = await client.getLeaderboard();
-
-    leaderboard.entries.forEach((entry, index) => {
-      const isMe = entry.player_guid === playerGuid;
-      const color = isMe ? '#00ff00' : '#ffffff';
-
-      this.add
-        .text(
-          400,
-          350 + index * 30,
-          `#${entry.rank} ${entry.player_name}: ${entry.score}`,
-          { fontSize: '18px', color },
-        )
-        .setOrigin(0.5);
-    });
-
-    // Show player's rank if not in top 10
-    const player = await client.getPlayerRank(playerGuid);
-    if (player && player.rank > 10) {
-      this.add
-        .text(400, 660, `... #${player.rank} ${playerName}: ${player.score}`, {
-          fontSize: '18px',
-          color: '#00ff00',
-        })
-        .setOrigin(0.5);
-    }
+    const snapshot = await leaderboard.getSnapshot({ limit: 10 });
+    this.displayLeaderboard(snapshot.entries);
   }
 }
 ```
 
 ---
 
-## Development
+## Utilities
 
-```bash
-# Install dependencies
-npm install
+### PlayerIdentity
 
-# Type check
-npm run typecheck
+Standalone helper for localStorage identity management:
 
-# Build
-npm run build
+```typescript
+import { PlayerIdentity } from 'keeperboard';
 
-# Run tests (requires .env with Supabase credentials)
-npm test
+const identity = new PlayerIdentity({ keyPrefix: 'myapp_' });
+const guid = identity.getOrCreatePlayerGuid();
+identity.setPlayerName('ACE');
+```
+
+### Cache
+
+Generic TTL cache with deduplication:
 
-# Clean
-npm run clean
+```typescript
+import { Cache } from 'keeperboard';
+
+const cache = new Cache<Data>(30000); // 30s TTL
+const data = await cache.getOrFetch(() => fetchData());
 ```
 
-### Running Tests
+### RetryQueue
 
-Copy `.env.example` to `.env` and fill in your Supabase credentials:
+localStorage-based retry for failed operations:
 
-```bash
-cp .env.example .env
+```typescript
+import { RetryQueue } from 'keeperboard';
+
+const queue = new RetryQueue('myapp_retry', 86400000); // 24h max age
+queue.save(1500, { level: 5 });
+const pending = queue.get(); // { score: 1500, metadata: {...} } or null
 ```
 
-Then run:
+---
+
+## Development
 
 ```bash
+# Install dependencies
+npm install
+
+# Run tests (requires local KeeperBoard server + Supabase)
 npm test
+
+# Type check
+npm run typecheck
+
+# Build
+npm run build
 ```
 
----
+See [MIGRATION.md](./MIGRATION.md) for upgrading from v1.x.
 
 ## License