@mpgd/game-services 0.8.0 → 0.8.2

package/dist/platform-order.js

@@ -37,8 +37,12 @@ function assertIdentifier(input, label) {
 }
 function assertIsoTimestamp(input, label) {
     if (typeof input !== 'string'
-        || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/u.test(input)
-        || Number.isNaN(Date.parse(input))) {
+        || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/u.test(input)) {
+        throw new TypeError(`${label} must be an ISO 8601 UTC timestamp.`);
+    }
+    const parsed = new Date(input);
+    const canonicalInput = input.includes('.') ? input : `${input.slice(0, -1)}.000Z`;
+    if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== canonicalInput) {
         throw new TypeError(`${label} must be an ISO 8601 UTC timestamp.`);
     }
 }

package/dist/verified-leaderboard.js

@@ -124,7 +124,7 @@ export class InMemoryVerifiedLeaderboardService {
     }
     createRankedEntries(definition) {
         return [...this.getRetainedAttempts(definition.leaderboardId).values()]
-            .sort((left, right) => compareAttempts(definition.scoreOrder, left, right))
+            .sort((left, right) => compareLeaderboardOrder(definition.scoreOrder, left, right))
             .map((attempt, index) => toRankedEntry(attempt, index + 1));
     }
 }
@@ -238,8 +238,10 @@ export function assertVerifiedLeaderboardSnapshot(input) {
     if (!Array.isArray(input.entries)) {
         throw new Error('entries must be an array.');
     }
+    const entries = [];
     for (const entry of input.entries) {
         assertLeaderboardRankedEntry(entry);
+        entries.push(entry);
     }
     if (input.participantEntry !== undefined) {
         assertLeaderboardRankedEntry(input.participantEntry);
@@ -249,8 +251,87 @@ export function assertVerifiedLeaderboardSnapshot(input) {
         || input.totalParticipants < 0) {
         throw new Error('totalParticipants must be a non-negative integer.');
     }
+    assertVerifiedLeaderboardSnapshotEntries(input.definition, entries, input.participantEntry, input.totalParticipants);
     assertTimestamp(input.generatedAt, 'generatedAt');
-    assertOptionalCursor(input.nextCursor);
+    assertVerifiedLeaderboardSnapshotCursor(input.definition, entries, input.totalParticipants, input.nextCursor);
+}
+function assertVerifiedLeaderboardSnapshotEntries(definition, entries, participantEntry, totalParticipants) {
+    const participantIds = new Set();
+    const attemptIds = new Set();
+    for (const [index, entry] of entries.entries()) {
+        if (entry.rank > totalParticipants) {
+            throw new Error('entry ranks must not exceed totalParticipants.');
+        }
+        if (participantIds.has(entry.participantId)) {
+            throw new Error('entries must not repeat a participantId.');
+        }
+        if (attemptIds.has(entry.attemptId)) {
+            throw new Error('entries must not repeat an attemptId.');
+        }
+        participantIds.add(entry.participantId);
+        attemptIds.add(entry.attemptId);
+        const previous = entries[index - 1];
+        if (previous === undefined) {
+            continue;
+        }
+        if (entry.rank !== previous.rank + 1) {
+            throw new Error('entry ranks must be contiguous within a snapshot page.');
+        }
+        if (compareLeaderboardOrder(definition.scoreOrder, previous, entry) >= 0) {
+            throw new Error('entries must follow the leaderboard ranking order.');
+        }
+    }
+    if (participantEntry !== undefined) {
+        if (participantEntry.rank > totalParticipants) {
+            throw new Error('participantEntry rank must not exceed totalParticipants.');
+        }
+        const overlappingEntry = entries.find((entry) => entry.rank === participantEntry.rank
+            || entry.participantId === participantEntry.participantId
+            || entry.attemptId === participantEntry.attemptId);
+        if (overlappingEntry !== undefined
+            && !areLeaderboardRankedEntriesEqual(overlappingEntry, participantEntry)) {
+            throw new Error('participantEntry must match overlapping snapshot entries.');
+        }
+        for (const entry of entries) {
+            if (entry.rank === participantEntry.rank) {
+                continue;
+            }
+            const order = compareLeaderboardOrder(definition.scoreOrder, participantEntry, entry);
+            const participantRanksBeforeEntry = participantEntry.rank < entry.rank;
+            if ((participantRanksBeforeEntry && order >= 0)
+                || (!participantRanksBeforeEntry && order <= 0)) {
+                throw new Error('participantEntry must follow the leaderboard ranking order.');
+            }
+        }
+    }
+}
+function areLeaderboardRankedEntriesEqual(left, right) {
+    return left.rank === right.rank
+        && left.participantId === right.participantId
+        && left.participantLabel === right.participantLabel
+        && left.attemptId === right.attemptId
+        && left.score === right.score
+        && parseTimestamp(left.completedAt) === parseTimestamp(right.completedAt)
+        && areVerifiedLeaderboardMetricsEqual(left.metrics, right.metrics);
+}
+function assertVerifiedLeaderboardSnapshotCursor(definition, entries, totalParticipants, nextCursor) {
+    assertOptionalCursor(nextCursor);
+    const lastEntry = entries.at(-1);
+    if (nextCursor === undefined) {
+        if (lastEntry !== undefined && lastEntry.rank < totalParticipants) {
+            throw new Error('nextCursor must be present when snapshot entries remain.');
+        }
+        return;
+    }
+    if (lastEntry === undefined) {
+        throw new Error('nextCursor requires at least one snapshot entry.');
+    }
+    if (lastEntry.rank >= totalParticipants) {
+        throw new Error('nextCursor must be omitted after the final snapshot entry.');
+    }
+    if (nextCursor !== createVerifiedLeaderboardCursor(definition, lastEntry)) {
+        throw new Error('nextCursor must continue after the final snapshot entry.');
+    }
 }
 export function createVerifiedLeaderboardCursor(definition, entry) {
     assertVerifiedLeaderboardDefinition(definition);
@@ -306,7 +387,7 @@ function shouldReplaceRetainedAttempt(definition, retained, candidate) {
     if (definition.attemptSelection === 'first') {
         return compareAttemptChronology(candidate, retained) < 0;
     }
-    return compareAttempts(definition.scoreOrder, candidate, retained) < 0;
+    return compareLeaderboardOrder(definition.scoreOrder, candidate, retained) < 0;
 }
 function compareAttemptChronology(left, right) {
     const completedAtComparison = parseTimestamp(left.completedAt) - parseTimestamp(right.completedAt);
@@ -315,7 +396,7 @@ function compareAttemptChronology(left, right) {
     }
     return compareOrdinal(left.attemptId, right.attemptId);
 }
-function compareAttempts(scoreOrder, left, right) {
+function compareLeaderboardOrder(scoreOrder, left, right) {
     if (left.score !== right.score) {
         return scoreOrder === 'ascending' ? left.score - right.score : right.score - left.score;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/game-services",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Client, contract, server, store, and test helpers for authoritative mpgd game services.",
   "license": "MIT",
   "repository": {