@mpgd/game-services 0.11.0 → 0.11.1

package/dist/client.d.ts

@@ -74,6 +74,7 @@ export interface CreateGameServicesClientInput {
   readonly backend: GameServicesBackendApi;
   readonly playerId: string;
   readonly target: GameServicesLedgerTarget;
+  readonly deploymentTarget?: string;
   readonly analytics?: AnalyticsSink;
   readonly analyticsSessionId?: string;
   readonly now?: () => string;

package/dist/client.js

@@ -83,6 +83,9 @@ export function createGameServicesClient(input) {
             }
             const verification = await input.backend.purchases.verifyPurchase({
                 target,
+                ...(input.deploymentTarget === undefined || input.deploymentTarget === target
+                    ? {}
+                    : { deploymentTarget: input.deploymentTarget }),
                 playerId: input.playerId,
                 productId: purchaseInput.productId,
                 platformTransactionId: purchase.transactionId,
@@ -148,6 +151,9 @@ export function createGameServicesClient(input) {
             }
             const claim = await input.backend.adRewards.claimAdReward({
                 target,
+                ...(input.deploymentTarget === undefined || input.deploymentTarget === target
+                    ? {}
+                    : { deploymentTarget: input.deploymentTarget }),
                 playerId: input.playerId,
                 placementId: rewardInput.placementId,
                 ...(reward.ledgerEntryId === undefined

package/dist/runtime.d.ts

@@ -17,6 +17,7 @@ export interface CreateGameServicesRuntimeInput {
   readonly playerId: string;
   readonly authorityMode: GameServicesAuthorityMode;
   readonly target?: PlatformTarget | string;
+  readonly deploymentTarget?: string;
   readonly baseUrl?: string;
   readonly transport?: 'http' | 'orpc';
   readonly allowLocalBackend?: boolean;

package/dist/runtime.js

@@ -46,6 +46,9 @@ export function createGameServicesRuntime(input) {
             backend,
             playerId: input.playerId,
             target,
+            ...(input.deploymentTarget === undefined
+                ? {}
+                : { deploymentTarget: input.deploymentTarget }),
             ...(input.analytics === undefined ? {} : { analytics: input.analytics }),
             ...(input.analyticsSessionId === undefined
                 ? {}

package/dist/server.d.ts

@@ -1,13 +1,15 @@
 import { type AnalyticsSink } from '@mpgd/analytics';
-import type { AdPlacements, ProductCatalog } from '@mpgd/catalog';
+import { type AdPlacements, type ProductCatalog } from '@mpgd/catalog';
 import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesBackendTransportRequest, type GameServicesBackendTransportResponse } from './client';
 import { type GameServicesHealthResponse } from './contract';
 import { type GameServicesEvidenceVerifier, type GameServicesPurchaseGrantFinalizer } from './evidence-verification';
-import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, type LeaderboardScoreTransaction, type ProductGrantTransaction, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types';
+import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, type GameServicesAdRewardTarget, type LeaderboardScoreTransaction, type ProductGrantTransaction, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types';
 type CorsHeaders = Record<string, string>;
 export interface CreateGameServicesBackendInput {
   readonly catalog: ProductCatalog;
   readonly placements: AdPlacements;
+  /** Trusted deployment-config bindings keyed by the request's platform target. */
+  readonly deploymentTargetBindings?: GameServicesDeploymentTargetBindings;
   readonly store?: GameServicesStore;
   readonly analytics?: AnalyticsSink;
   readonly analyticsSessionId?: string;
@@ -18,6 +20,7 @@ export interface CreateGameServicesBackendInput {
   readonly purchaseGrantFinalizationTimeoutMs?: number;
   readonly purchaseGrantFinalizer?: GameServicesPurchaseGrantFinalizer;
 }
+export type GameServicesDeploymentTargetBindings = Readonly<Partial<Record<GameServicesAdRewardTarget, string>>>;
 export interface GameServicesBackendApiHandler {
   readonly version?: string;
   handle(request: GameServicesBackendTransportRequest): Promise<GameServicesBackendTransportResponse>;

package/dist/server.js

@@ -1,10 +1,11 @@
 import { implement } from '@orpc/server';
 import { RPCHandler } from '@orpc/server/fetch';
 import { createAnalyticsReporter } from '@mpgd/analytics';
+import { resolveAdPlacementPlatformId, resolveProductPlatformId, } from '@mpgd/catalog';
 import { gameServicesBackendEndpoints, } from './client';
 import { gameServicesContract } from './contract';
 import { createRejectingGameServicesEvidenceVerifier, } from './evidence-verification';
-import { assertClaimAdRewardRequest, assertClaimAdRewardResponse, assertEntitlementLedgerGrant, assertEntitlementLedgerResult, assertLeaderboardScoreTransaction, assertProductGrantTransaction, assertPurchaseGrantFinalization, assertRecordLeaderboardScoreRequest, assertRecordLeaderboardScoreResponse, assertVerifyPurchaseRequest, assertVerifyPurchaseResponse, } from './types';
+import { assertClaimAdRewardRequest, assertClaimAdRewardResponse, assertEntitlementLedgerGrant, assertEntitlementLedgerResult, assertGameServicesDeploymentTarget, assertLeaderboardScoreTransaction, assertProductGrantTransaction, assertPurchaseGrantFinalization, assertRecordLeaderboardScoreRequest, assertRecordLeaderboardScoreResponse, assertVerifyPurchaseRequest, assertVerifyPurchaseResponse, } from './types';
 export class InMemoryGameServicesStore {
     entitlementTransactionsByKey = new Map();
     entitlementTransactionsByEvidence = new Map();
@@ -130,6 +131,7 @@ export function createGameServicesBackend(input) {
     const evidenceVerifier = input.evidenceVerifier ?? createRejectingGameServicesEvidenceVerifier();
     const evidenceVerificationTimeoutMs = resolveEvidenceVerificationTimeout(input.evidenceVerificationTimeoutMs);
     const purchaseGrantFinalizationTimeoutMs = resolvePurchaseGrantFinalizationTimeout(input.purchaseGrantFinalizationTimeoutMs);
+    const deploymentTargetBindings = resolveDeploymentTargetBindings(input.deploymentTargetBindings);
     const analytics = createAnalyticsReporter({
         target: 'server',
         sessionId: input.analyticsSessionId ?? 'game-services',
@@ -147,6 +149,7 @@ export function createGameServicesBackend(input) {
                     evidenceVerifier,
                     evidenceVerificationTimeoutMs,
                     purchaseGrantFinalizationTimeoutMs,
+                    deploymentTargetBindings,
                     ...(input.purchaseGrantFinalizer === undefined
                         ? {}
                         : { purchaseGrantFinalizer: input.purchaseGrantFinalizer }),
@@ -177,6 +180,7 @@ export function createGameServicesBackend(input) {
                     now,
                     evidenceVerifier,
                     evidenceVerificationTimeoutMs,
+                    deploymentTargetBindings,
                 });
                 await analytics.track({
                     name: claim.granted ? 'rewarded_ad_granted' : 'rewarded_ad_rejected',
@@ -313,14 +317,44 @@ export function createGameServicesHttpFetchHandler(handler, options = {}) {
         }
     };
 }
+const gameServicesDeploymentTargetPlatforms = new Set([
+    'android',
+    'ios',
+    'ait',
+    'verse8',
+]);
+function resolveDeploymentTargetBindings(input) {
+    const bindings = {};
+    for (const [platformTarget, deploymentTarget] of Object.entries(input ?? {})) {
+        if (!gameServicesDeploymentTargetPlatforms.has(platformTarget)) {
+            throw new Error(`Unsupported deployment target binding platform: ${platformTarget}.`);
+        }
+        assertGameServicesDeploymentTarget(deploymentTarget);
+        bindings[platformTarget] = deploymentTarget;
+    }
+    return bindings;
+}
+function bindRequestDeploymentTarget(request, bindings) {
+    const deploymentTarget = bindings[request.target] ?? request.target;
+    if (request.deploymentTarget !== undefined
+        && request.deploymentTarget !== deploymentTarget) {
+        throw new Error(`deploymentTarget must match the backend binding for ${request.target}.`);
+    }
+    return deploymentTarget === request.target || request.deploymentTarget === deploymentTarget
+        ? request
+        : { ...request, deploymentTarget };
+}
 async function verifyPurchaseWithStore(input, context) {
-    const request = assertVerifyPurchaseRequest(input);
+    const request = bindRequestDeploymentTarget(assertVerifyPurchaseRequest(input), context.deploymentTargetBindings);
     const retryIdentity = {
         source: 'purchase',
         playerId: request.playerId,
         idempotencyKey: request.idempotencyKey,
         grantId: request.productId,
         target: request.target,
+        ...(request.deploymentTarget === undefined
+            ? {}
+            : { deploymentTarget: request.deploymentTarget }),
     };
     const completeExistingRetry = async (transaction) => {
         if (!matchesEntitlementRetry(transaction, retryIdentity)) {
@@ -350,7 +384,7 @@ async function verifyPurchaseWithStore(input, context) {
             reason: 'UNKNOWN_PRODUCT',
         });
     }
-    const platformProductId = product.platformProductIds[request.target];
+    const platformProductId = resolveProductPlatformId(product, request.deploymentTarget ?? request.target);
     if (platformProductId === undefined) {
         return assertVerifyPurchaseResponse({
             verified: false,
@@ -394,6 +428,9 @@ async function verifyPurchaseWithStore(input, context) {
         payload: {
             ...verificationPayload,
             target: request.target,
+            ...(request.deploymentTarget === undefined
+                ? {}
+                : { deploymentTarget: request.deploymentTarget }),
             productId: request.productId,
             productType: product.type,
             platformProductId,
@@ -569,13 +606,16 @@ function createStoredPurchaseRequest(request, transaction) {
     };
 }
 async function claimAdRewardWithStore(input, context) {
-    const request = assertClaimAdRewardRequest(input);
+    const request = bindRequestDeploymentTarget(assertClaimAdRewardRequest(input), context.deploymentTargetBindings);
     const retryIdentity = {
         source: 'ad_reward',
         playerId: request.playerId,
         idempotencyKey: request.idempotencyKey,
         grantId: request.placementId,
         target: request.target,
+        ...(request.deploymentTarget === undefined
+            ? {}
+            : { deploymentTarget: request.deploymentTarget }),
     };
     const existing = await findEntitlementTransactionByIdempotency(context.store, retryIdentity);
     if (existing !== undefined) {
@@ -600,7 +640,7 @@ async function claimAdRewardWithStore(input, context) {
             reason: placement === undefined ? 'UNKNOWN_PLACEMENT' : 'NOT_REWARDED_PLACEMENT',
         });
     }
-    const platformPlacementId = placement.platformPlacementIds[request.target];
+    const platformPlacementId = resolveAdPlacementPlatformId(placement, request.deploymentTarget ?? request.target);
     const verification = await verifyEvidence((signal) => {
         return context.evidenceVerifier.verifyAdReward({
             request,
@@ -622,6 +662,9 @@ async function claimAdRewardWithStore(input, context) {
     const payload = {
         ...verification.payload,
         target: request.target,
+        ...(request.deploymentTarget === undefined
+            ? {}
+            : { deploymentTarget: request.deploymentTarget }),
         placementId: request.placementId,
         rewardType: placement.reward.type,
         amount: placement.reward.amount,
@@ -908,7 +951,8 @@ function matchesEntitlementRetry(transaction, identity) {
         && transaction.playerId === identity.playerId
         && transaction.idempotencyKey === identity.idempotencyKey
         && transaction.grantId === identity.grantId
-        && transaction.payload.target === identity.target;
+        && transaction.payload.target === identity.target
+        && transaction.payload.deploymentTarget === identity.deploymentTarget;
 }
 function resolveEvidenceVerificationTimeout(timeoutMs) {
     const resolved = timeoutMs ?? 10000;

package/dist/types.d.ts

@@ -12,6 +12,8 @@ export type EntitlementLedgerSource = 'purchase' | 'ad_reward' | 'admin';
 export type EntitlementLedgerPayload = Record<string, string | number | boolean>;
 export interface VerifyPurchaseRequest {
   readonly target: GameServicesStoreTarget;
+  /** Deployment config key used to resolve game-owned platform product identifiers. */
+  readonly deploymentTarget?: string;
   readonly playerId: string;
   readonly productId: LogicalProductId;
   readonly platformTransactionId: string;
@@ -35,6 +37,8 @@ export interface PurchaseGrantFinalization {
 }
 export interface ClaimAdRewardRequest {
   readonly target: GameServicesAdRewardTarget;
+  /** Deployment config key used to resolve game-owned platform placement identifiers. */
+  readonly deploymentTarget?: string;
   readonly playerId: string;
   readonly placementId: LogicalAdPlacementId;
   /** Platform evidence identity; AIT uses the game-issued reward correlation identifier. */
@@ -100,3 +104,4 @@ export declare function assertEntitlementLedgerGrant(input: EntitlementLedgerGra
 export declare function assertEntitlementLedgerResult(input: EntitlementLedgerResult): EntitlementLedgerResult;
 export declare function assertProductGrantTransaction(input: ProductGrantTransaction): ProductGrantTransaction;
 export declare function assertLeaderboardScoreTransaction(input: LeaderboardScoreTransaction): LeaderboardScoreTransaction;
+export declare function assertGameServicesDeploymentTarget(input: unknown): asserts input is string;

package/dist/types.js

@@ -1,6 +1,7 @@
 export function assertVerifyPurchaseRequest(input) {
     assertRecord(input, 'VerifyPurchaseRequest');
     assertStoreTarget(input.target);
+    assertOptionalGameServicesDeploymentTarget(input.deploymentTarget);
     assertNonEmptyString(input.playerId, 'playerId');
     assertNonEmptyString(input.productId, 'productId');
     assertNonEmptyString(input.platformTransactionId, 'platformTransactionId');
@@ -44,6 +45,7 @@ export function assertPurchaseGrantFinalization(input) {
 export function assertClaimAdRewardRequest(input) {
     assertRecord(input, 'ClaimAdRewardRequest');
     assertAdRewardTarget(input.target);
+    assertOptionalGameServicesDeploymentTarget(input.deploymentTarget);
     assertNonEmptyString(input.playerId, 'playerId');
     assertNonEmptyString(input.placementId, 'placementId');
     assertOptionalNonEmptyString(input.platformImpressionId, 'platformImpressionId');
@@ -135,6 +137,34 @@ function assertAdRewardTarget(input) {
         throw new Error('target must be android, ios, ait, or verse8.');
     }
 }
+export function assertGameServicesDeploymentTarget(input) {
+    if (typeof input !== 'string'
+        || input.length > 64
+        || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(input)
+        || reservedDeploymentTargetNames.has(input)) {
+        throw new Error('deploymentTarget must use lowercase kebab-case and avoid reserved names.');
+    }
+}
+function assertOptionalGameServicesDeploymentTarget(input) {
+    if (input === undefined) {
+        return;
+    }
+    assertGameServicesDeploymentTarget(input);
+}
+const reservedDeploymentTargetNames = new Set([
+    'aux',
+    'browser',
+    'con',
+    'devvit',
+    'index',
+    'msstore',
+    'nul',
+    'prn',
+    'constructor',
+    'prototype',
+    ...Array.from({ length: 9 }, (_, index) => `com${String(index + 1)}`),
+    ...Array.from({ length: 9 }, (_, index) => `lpt${String(index + 1)}`),
+]);
 function assertLeaderboardTarget(input) {
     if (input !== 'browser'
         && input !== 'android'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/game-services",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Client, contract, server, store, and test helpers for authoritative mpgd game services.",
   "license": "MIT",
   "repository": {
@@ -126,8 +126,8 @@
     "@orpc/client": "2.0.0-beta.14",
     "@orpc/contract": "2.0.0-beta.14",
     "@orpc/server": "2.0.0-beta.14",
-    "@mpgd/catalog": "0.5.1",
     "@mpgd/analytics": "0.3.8",
+    "@mpgd/catalog": "0.5.2",
     "@mpgd/platform": "0.8.0"
   },
   "devDependencies": {