@mpgd/game-services 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 imjlk
+
+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/dist/client.d.ts

@@ -0,0 +1,122 @@
+import { type AnalyticsSink } from '@mpgd/analytics';
+import type { LeaderboardScoreInput, LogicalAdPlacementId, LogicalProductId, PlatformGateway, PlatformTarget, PurchaseResult, RewardedAdResult } from '@mpgd/platform';
+import type { GameServicesContractClient } from './contract';
+import type { ClaimAdRewardRequest, ClaimAdRewardResponse, GameServicesStoreTarget, RecordLeaderboardScoreRequest, RecordLeaderboardScoreResponse, VerifyPurchaseRequest, VerifyPurchaseResponse } from './types';
+export interface PurchaseVerificationApi {
+  verifyPurchase(input: VerifyPurchaseRequest): Promise<VerifyPurchaseResponse>;
+}
+export interface AdRewardClaimApi {
+  claimAdReward(input: ClaimAdRewardRequest): Promise<ClaimAdRewardResponse>;
+}
+export interface LeaderboardRecordApi {
+  recordScore(input: RecordLeaderboardScoreRequest): Promise<RecordLeaderboardScoreResponse>;
+}
+export interface GameServicesBackendApi {
+  readonly version?: string;
+  readonly purchases: PurchaseVerificationApi;
+  readonly adRewards: AdRewardClaimApi;
+  readonly leaderboard: LeaderboardRecordApi;
+}
+export declare const gameServicesBackendEndpoints: {
+  readonly verifyPurchase: '/game-services/purchases/verify';
+  readonly claimAdReward: '/game-services/ad-rewards/claim';
+  readonly recordLeaderboardScore: '/game-services/leaderboard/record';
+};
+export type GameServicesBackendEndpoint = (typeof gameServicesBackendEndpoints)[keyof typeof gameServicesBackendEndpoints];
+export interface GameServicesBackendTransportRequest<TBody = unknown> {
+  readonly method: 'POST';
+  readonly endpoint: GameServicesBackendEndpoint;
+  readonly body: TBody;
+}
+export interface GameServicesBackendTransportResponse<TBody = unknown> {
+  readonly status: number;
+  readonly body: TBody;
+}
+export interface GameServicesBackendTransport {
+  send(request: GameServicesBackendTransportRequest): Promise<GameServicesBackendTransportResponse>;
+}
+export interface CreateGameServicesHttpBackendApiInput {
+  readonly transport: GameServicesBackendTransport;
+}
+export interface CreateGameServicesFetchBackendTransportInput {
+  readonly baseUrl: string;
+  readonly fetch?: GameServicesFetch;
+  readonly headers?: Record<string, string>;
+}
+export interface CreateGameServicesOrpcClientInput {
+  readonly url: string;
+  readonly fetch?: typeof fetch;
+  readonly headers?: Record<string, string>;
+}
+export type GameServicesFetch = (url: string, init: {
+  readonly method: 'POST';
+  readonly headers: Record<string, string>;
+  readonly body: string;
+}) => Promise<GameServicesFetchResponse>;
+export interface GameServicesFetchResponse {
+  readonly ok: boolean;
+  readonly status: number;
+  text(): Promise<string>;
+}
+export declare class GameServicesBackendError extends Error {
+  readonly endpoint: GameServicesBackendEndpoint;
+  readonly status: number;
+  readonly body: unknown;
+  constructor(endpoint: GameServicesBackendEndpoint, status: number, body: unknown);
+}
+export interface GameServicesClient {
+  purchase(input: GameServicesPurchaseInput): Promise<GameServicesPurchaseResult>;
+  claimRewardedAd(input: GameServicesRewardedAdInput): Promise<GameServicesRewardedAdResult>;
+  submitLeaderboardScore(input: GameServicesLeaderboardInput): Promise<GameServicesLeaderboardResult>;
+}
+export interface CreateGameServicesClientInput {
+  readonly gateway: PlatformGateway;
+  readonly backend: GameServicesBackendApi;
+  readonly playerId: string;
+  readonly target: GameServicesStoreTarget;
+  readonly analytics?: AnalyticsSink;
+  readonly analyticsSessionId?: string;
+  readonly now?: () => string;
+}
+export interface GameServicesPurchaseInput {
+  readonly productId: LogicalProductId;
+  readonly source: 'shop' | 'stage_fail' | 'result' | 'event';
+  readonly idempotencyKey: string;
+}
+export interface GameServicesPurchaseResult {
+  readonly status: 'granted' | 'cancelled' | 'pending' | 'failed' | 'rejected';
+  readonly purchase: PurchaseResult;
+  readonly verification?: VerifyPurchaseResponse;
+  readonly ledgerEntryId?: string;
+}
+export interface GameServicesRewardedAdInput {
+  readonly placementId: LogicalAdPlacementId;
+  readonly idempotencyKey: string;
+}
+export interface GameServicesRewardedAdResult {
+  readonly status: 'granted' | 'skipped' | 'unavailable' | 'failed' | 'rejected';
+  readonly reward: RewardedAdResult;
+  readonly claim?: ClaimAdRewardResponse;
+  readonly ledgerEntryId?: string;
+}
+export interface GameServicesLeaderboardInput extends LeaderboardScoreInput {
+}
+export interface GameServicesLeaderboardResult {
+  readonly submitted: boolean;
+  readonly platformSubmitted: boolean;
+  readonly rank?: number;
+  readonly ledgerEntryId?: string;
+  readonly alreadyProcessed: boolean;
+}
+export declare function createGameServicesClient(input: CreateGameServicesClientInput): GameServicesClient;
+export declare function createGameServicesHttpBackendApi(input: CreateGameServicesHttpBackendApiInput): GameServicesBackendApi;
+export declare function createGameServicesFetchBackendTransport(input: CreateGameServicesFetchBackendTransportInput): GameServicesBackendTransport;
+export declare function createGameServicesOrpcClient(input: CreateGameServicesOrpcClientInput): GameServicesContractClient;
+export declare function createGameServicesOrpcBackendApi(client: GameServicesContractClient): GameServicesBackendApi;
+export declare function createGameServicesIdempotencyKey(input: {
+  readonly target: PlatformTarget;
+  readonly playerId: string;
+  readonly action: 'purchase' | 'rewarded-ad' | 'leaderboard';
+  readonly subjectId: string;
+  readonly runId: string;
+}): string;

package/dist/client.js

@@ -0,0 +1,270 @@
+import { createORPCClient } from '@orpc/client';
+import { RPCLink } from '@orpc/client/fetch';
+import { createAnalyticsReporter } from '@mpgd/analytics';
+export const gameServicesBackendEndpoints = {
+    verifyPurchase: '/game-services/purchases/verify',
+    claimAdReward: '/game-services/ad-rewards/claim',
+    recordLeaderboardScore: '/game-services/leaderboard/record',
+};
+export class GameServicesBackendError extends Error {
+    endpoint;
+    status;
+    body;
+    constructor(endpoint, status, body) {
+        super(`GameServices backend request failed: ${endpoint} ${status}`);
+        this.name = 'GameServicesBackendError';
+        this.endpoint = endpoint;
+        this.status = status;
+        this.body = body;
+    }
+}
+export function createGameServicesClient(input) {
+    const now = input.now ?? (() => new Date().toISOString());
+    const analytics = createAnalyticsReporter({
+        target: input.target,
+        sessionId: input.analyticsSessionId ?? input.playerId,
+        now,
+        ...(input.analytics === undefined ? {} : { sink: input.analytics }),
+    });
+    return {
+        async purchase(purchaseInput) {
+            const purchase = await input.gateway.commerce.purchase(purchaseInput);
+            if (purchase.status !== 'completed' || purchase.transactionId === undefined) {
+                await analytics.track({
+                    name: 'purchase_rejected',
+                    properties: {
+                        productId: purchaseInput.productId,
+                        status: purchase.status,
+                        reason: purchase.transactionId === undefined ? 'missing_transaction_id' : undefined,
+                    },
+                });
+                return {
+                    status: purchase.status === 'completed' ? 'rejected' : purchase.status,
+                    purchase,
+                };
+            }
+            const verification = await input.backend.purchases.verifyPurchase({
+                target: input.target,
+                playerId: input.playerId,
+                productId: purchaseInput.productId,
+                platformTransactionId: purchase.transactionId,
+                idempotencyKey: purchaseInput.idempotencyKey,
+                purchasedAt: now(),
+            });
+            const result = {
+                status: verification.verified ? 'granted' : 'rejected',
+                purchase,
+                verification,
+                ...(verification.ledgerEntryId === undefined
+                    ? {}
+                    : { ledgerEntryId: verification.ledgerEntryId }),
+            };
+            await analytics.track({
+                name: verification.verified ? 'purchase_granted' : 'purchase_rejected',
+                properties: {
+                    productId: purchaseInput.productId,
+                    status: result.status,
+                    ledgerEntryId: verification.ledgerEntryId,
+                    alreadyProcessed: verification.alreadyProcessed,
+                    reason: verification.reason,
+                },
+            });
+            return result;
+        },
+        async claimRewardedAd(rewardInput) {
+            const reward = await input.gateway.ads.showRewarded(rewardInput);
+            if (reward.status !== 'completed' || !reward.rewardGranted) {
+                await analytics.track({
+                    name: 'rewarded_ad_rejected',
+                    properties: {
+                        placementId: rewardInput.placementId,
+                        status: reward.status,
+                        rewardGranted: reward.rewardGranted,
+                    },
+                });
+                return {
+                    status: reward.status === 'completed' ? 'rejected' : reward.status,
+                    reward,
+                };
+            }
+            const claim = await input.backend.adRewards.claimAdReward({
+                target: input.target,
+                playerId: input.playerId,
+                placementId: rewardInput.placementId,
+                ...(reward.ledgerEntryId === undefined
+                    ? {}
+                    : { platformImpressionId: reward.ledgerEntryId }),
+                idempotencyKey: rewardInput.idempotencyKey,
+                completedAt: now(),
+            });
+            const result = {
+                status: claim.granted ? 'granted' : 'rejected',
+                reward,
+                claim,
+                ...(claim.ledgerEntryId === undefined ? {} : { ledgerEntryId: claim.ledgerEntryId }),
+            };
+            await analytics.track({
+                name: claim.granted ? 'rewarded_ad_granted' : 'rewarded_ad_rejected',
+                properties: {
+                    placementId: rewardInput.placementId,
+                    status: result.status,
+                    ledgerEntryId: claim.ledgerEntryId,
+                    alreadyProcessed: claim.alreadyProcessed,
+                    reason: claim.reason,
+                },
+            });
+            return result;
+        },
+        async submitLeaderboardScore(scoreInput) {
+            const platformResult = await input.gateway.leaderboard.submitScore(scoreInput);
+            if (!platformResult.submitted) {
+                await analytics.track({
+                    name: 'leaderboard_submitted',
+                    properties: {
+                        leaderboardId: scoreInput.leaderboardId,
+                        score: scoreInput.score,
+                        submitted: false,
+                    },
+                });
+                return {
+                    submitted: false,
+                    platformSubmitted: false,
+                    alreadyProcessed: false,
+                };
+            }
+            const record = await input.backend.leaderboard.recordScore({
+                target: input.target,
+                playerId: input.playerId,
+                ...scoreInput,
+            });
+            const result = {
+                submitted: record.submitted,
+                platformSubmitted: true,
+                rank: record.rank,
+                ledgerEntryId: record.ledgerEntryId,
+                alreadyProcessed: record.alreadyProcessed,
+            };
+            await analytics.track({
+                name: 'leaderboard_recorded',
+                properties: {
+                    leaderboardId: scoreInput.leaderboardId,
+                    score: scoreInput.score,
+                    submitted: result.submitted,
+                    rank: result.rank,
+                    ledgerEntryId: result.ledgerEntryId,
+                    alreadyProcessed: result.alreadyProcessed,
+                },
+            });
+            return result;
+        },
+    };
+}
+export function createGameServicesHttpBackendApi(input) {
+    return {
+        purchases: {
+            async verifyPurchase(body) {
+                return sendGameServicesBackendRequest(input.transport, gameServicesBackendEndpoints.verifyPurchase, body);
+            },
+        },
+        adRewards: {
+            async claimAdReward(body) {
+                return sendGameServicesBackendRequest(input.transport, gameServicesBackendEndpoints.claimAdReward, body);
+            },
+        },
+        leaderboard: {
+            async recordScore(body) {
+                return sendGameServicesBackendRequest(input.transport, gameServicesBackendEndpoints.recordLeaderboardScore, body);
+            },
+        },
+    };
+}
+export function createGameServicesFetchBackendTransport(input) {
+    const fetcher = input.fetch ?? readGlobalFetch();
+    return {
+        async send(request) {
+            const response = await fetcher(joinUrl(input.baseUrl, request.endpoint), {
+                method: request.method,
+                headers: {
+                    ...(input.headers ?? {}),
+                    'content-type': 'application/json',
+                },
+                body: JSON.stringify(request.body),
+            });
+            return {
+                status: response.status,
+                body: await readFetchResponseBody(response),
+            };
+        },
+    };
+}
+export function createGameServicesOrpcClient(input) {
+    const link = new RPCLink({
+        origin: input.url,
+        ...(input.fetch === undefined ? {} : { fetch: input.fetch }),
+        ...(input.headers === undefined
+            ? {}
+            : {
+                headers: () => input.headers,
+            }),
+    });
+    return createORPCClient(link);
+}
+export function createGameServicesOrpcBackendApi(client) {
+    return {
+        purchases: {
+            verifyPurchase(input) {
+                return client.commerce.verifyPurchase(input);
+            },
+        },
+        adRewards: {
+            claimAdReward(input) {
+                return client.ads.claimReward(input);
+            },
+        },
+        leaderboard: {
+            recordScore(input) {
+                return client.leaderboard.recordScore(input);
+            },
+        },
+    };
+}
+export function createGameServicesIdempotencyKey(input) {
+    return [
+        input.action,
+        normalizeSegment(input.target),
+        normalizeSegment(input.playerId),
+        normalizeSegment(input.subjectId),
+        normalizeSegment(input.runId),
+    ].join(':');
+}
+function normalizeSegment(value) {
+    return value.replaceAll(/[^a-zA-Z0-9_-]+/g, '-').replaceAll(/^-|-$/g, '').slice(0, 64);
+}
+async function sendGameServicesBackendRequest(transport, endpoint, body) {
+    const response = await transport.send({
+        method: 'POST',
+        endpoint,
+        body,
+    });
+    if (response.status < 200 || response.status >= 300) {
+        throw new GameServicesBackendError(endpoint, response.status, response.body);
+    }
+    return response.body;
+}
+function readGlobalFetch() {
+    const fetcher = globalThis.fetch;
+    if (fetcher === undefined) {
+        throw new Error('globalThis.fetch is unavailable. Provide a GameServices fetch implementation.');
+    }
+    return fetcher;
+}
+async function readFetchResponseBody(response) {
+    const text = await response.text();
+    if (text.length === 0) {
+        return null;
+    }
+    return JSON.parse(text);
+}
+function joinUrl(baseUrl, endpoint) {
+    return `${baseUrl.replace(/\/+$/g, '')}${endpoint}`;
+}

package/dist/contract.d.ts

@@ -0,0 +1,21 @@
+import { type RouterContractClient } from '@orpc/contract';
+import type { ClaimAdRewardRequest, ClaimAdRewardResponse, RecordLeaderboardScoreRequest, RecordLeaderboardScoreResponse, VerifyPurchaseRequest, VerifyPurchaseResponse } from './types';
+export interface GameServicesHealthResponse {
+  readonly ok: true;
+  readonly service: 'game-services';
+  readonly version: string;
+}
+export declare const gameServicesContract: {
+  health: import("@orpc/contract").ProcedureContract<import("@orpc/contract").Schema<void, void>, import("@orpc/contract").Schema<GameServicesHealthResponse, GameServicesHealthResponse>, object>;
+  commerce: {
+    verifyPurchase: import("@orpc/contract").ProcedureContract<import("@orpc/contract").Schema<VerifyPurchaseRequest, VerifyPurchaseRequest>, import("@orpc/contract").Schema<VerifyPurchaseResponse, VerifyPurchaseResponse>, object>;
+  };
+  ads: {
+    claimReward: import("@orpc/contract").ProcedureContract<import("@orpc/contract").Schema<ClaimAdRewardRequest, ClaimAdRewardRequest>, import("@orpc/contract").Schema<ClaimAdRewardResponse, ClaimAdRewardResponse>, object>;
+  };
+  leaderboard: {
+    recordScore: import("@orpc/contract").ProcedureContract<import("@orpc/contract").Schema<RecordLeaderboardScoreRequest, RecordLeaderboardScoreRequest>, import("@orpc/contract").Schema<RecordLeaderboardScoreResponse, RecordLeaderboardScoreResponse>, object>;
+  };
+};
+export type GameServicesContract = typeof gameServicesContract;
+export type GameServicesContractClient = RouterContractClient<GameServicesContract>;

package/dist/contract.js

@@ -0,0 +1,21 @@
+import { oc, type as orpcType } from '@orpc/contract';
+export const gameServicesContract = oc.router({
+    health: oc
+        .input(orpcType())
+        .output(orpcType()),
+    commerce: oc.router({
+        verifyPurchase: oc
+            .input(orpcType())
+            .output(orpcType()),
+    }),
+    ads: oc.router({
+        claimReward: oc
+            .input(orpcType())
+            .output(orpcType()),
+    }),
+    leaderboard: oc.router({
+        recordScore: oc
+            .input(orpcType())
+            .output(orpcType()),
+    }),
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './client';
+export * from './contract';
+export * from './server';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './client';
+export * from './contract';
+export * from './server';
+export * from './types';

package/dist/server.d.ts

@@ -0,0 +1,78 @@
+import { type AnalyticsSink } from '@mpgd/analytics';
+import type { AdPlacements, ProductCatalog } from '@mpgd/catalog';
+import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesBackendTransportRequest, type GameServicesBackendTransportResponse } from './client';
+import { type GameServicesHealthResponse } from './contract';
+import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, 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;
+  readonly store?: GameServicesStore;
+  readonly analytics?: AnalyticsSink;
+  readonly analyticsSessionId?: string;
+  readonly now?: () => string;
+  readonly version?: string;
+}
+export interface GameServicesBackendApiHandler {
+  readonly version?: string;
+  handle(request: GameServicesBackendTransportRequest): Promise<GameServicesBackendTransportResponse>;
+}
+export interface GameServicesBackendErrorResponse {
+  readonly error: string;
+}
+export interface GameServicesStore {
+  recordEntitlementGrant(input: EntitlementLedgerGrant): Promise<EntitlementLedgerResult>;
+  getEntitlementTransaction(ledgerEntryId: string): Promise<ProductGrantTransaction | undefined>;
+  listEntitlementTransactions(): Promise<readonly ProductGrantTransaction[]>;
+  recordLeaderboardScore(input: RecordLeaderboardScoreRequest, options?: {
+    readonly recordedAt?: string;
+  }): Promise<RecordLeaderboardScoreResponse>;
+  getLeaderboardTransaction(ledgerEntryId: string): Promise<LeaderboardScoreTransaction | undefined>;
+  listLeaderboardTransactions(): Promise<readonly LeaderboardScoreTransaction[]>;
+}
+export interface CreateGameServicesFetchHandlerOptions {
+  readonly corsHeaders?: CorsHeaders;
+  readonly healthPath?: string;
+  readonly version?: string;
+}
+export interface CreateGameServicesRpcFetchHandlerOptions extends CreateGameServicesFetchHandlerOptions {
+  readonly prefix?: string;
+}
+export interface GameServicesOrpcContext {
+  readonly request?: Request;
+}
+export declare class InMemoryGameServicesStore implements GameServicesStore {
+  private readonly entitlementTransactionsByKey;
+  private readonly entitlementTransactionsById;
+  private readonly leaderboardTransactionsByRun;
+  private readonly leaderboardTransactionsById;
+  recordEntitlementGrant(input: EntitlementLedgerGrant): Promise<EntitlementLedgerResult>;
+  getEntitlementTransaction(ledgerEntryId: string): Promise<ProductGrantTransaction | undefined>;
+  listEntitlementTransactions(): Promise<readonly ProductGrantTransaction[]>;
+  recordLeaderboardScore(input: RecordLeaderboardScoreRequest, options?: {
+    readonly recordedAt?: string;
+  }): Promise<RecordLeaderboardScoreResponse>;
+  getLeaderboardTransaction(ledgerEntryId: string): Promise<LeaderboardScoreTransaction | undefined>;
+  listLeaderboardTransactions(): Promise<readonly LeaderboardScoreTransaction[]>;
+  private rankFor;
+  private sortedLeaderboardTransactions;
+}
+export declare function createInMemoryGameServicesStore(): InMemoryGameServicesStore;
+export declare function createGameServicesBackend(input: CreateGameServicesBackendInput): GameServicesBackendApi;
+export declare function createGameServicesBackendApiHandler(input: CreateGameServicesBackendInput): GameServicesBackendApiHandler;
+export declare function createInProcessGameServicesBackendTransport(handler: GameServicesBackendApiHandler): GameServicesBackendTransport;
+export declare function createGameServicesRouter(backend: GameServicesBackendApi): {
+  health: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<void, void>, import("@orpc/contract").Schema<GameServicesHealthResponse, GameServicesHealthResponse>, object>;
+  commerce: {
+    verifyPurchase: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<VerifyPurchaseRequest, VerifyPurchaseRequest>, import("@orpc/contract").Schema<VerifyPurchaseResponse, VerifyPurchaseResponse>, object>;
+  };
+  ads: {
+    claimReward: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<ClaimAdRewardRequest, ClaimAdRewardRequest>, import("@orpc/contract").Schema<ClaimAdRewardResponse, ClaimAdRewardResponse>, object>;
+  };
+  leaderboard: {
+    recordScore: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<RecordLeaderboardScoreRequest, RecordLeaderboardScoreRequest>, import("@orpc/contract").Schema<RecordLeaderboardScoreResponse, RecordLeaderboardScoreResponse>, object>;
+  };
+};
+export declare function createGameServicesRpcFetchHandler(router: ReturnType<typeof createGameServicesRouter>, options?: CreateGameServicesRpcFetchHandlerOptions): (request: Request) => Promise<Response>;
+export declare function createGameServicesHttpFetchHandler(handler: GameServicesBackendApiHandler, options?: CreateGameServicesFetchHandlerOptions): (request: Request) => Promise<Response>;
+export {};

package/dist/server.js

@@ -0,0 +1,474 @@
+import { implement } from '@orpc/server';
+import { RPCHandler } from '@orpc/server/fetch';
+import { createAnalyticsReporter } from '@mpgd/analytics';
+import { gameServicesBackendEndpoints, } from './client';
+import { gameServicesContract } from './contract';
+import { assertClaimAdRewardRequest, assertClaimAdRewardResponse, assertEntitlementLedgerGrant, assertEntitlementLedgerResult, assertLeaderboardScoreTransaction, assertProductGrantTransaction, assertRecordLeaderboardScoreRequest, assertRecordLeaderboardScoreResponse, assertVerifyPurchaseRequest, assertVerifyPurchaseResponse, } from './types';
+export class InMemoryGameServicesStore {
+    entitlementTransactionsByKey = new Map();
+    entitlementTransactionsById = new Map();
+    leaderboardTransactionsByRun = new Map();
+    leaderboardTransactionsById = new Map();
+    async recordEntitlementGrant(input) {
+        const grant = assertEntitlementLedgerGrant(input);
+        const key = createEntitlementIdempotencyKey(grant);
+        const existing = this.entitlementTransactionsByKey.get(key);
+        if (existing !== undefined) {
+            return assertEntitlementLedgerResult({
+                ledgerEntryId: existing.ledgerEntryId,
+                alreadyProcessed: true,
+            });
+        }
+        const transaction = createEntitlementTransaction(grant);
+        this.entitlementTransactionsByKey.set(key, transaction);
+        this.entitlementTransactionsById.set(transaction.ledgerEntryId, transaction);
+        return assertEntitlementLedgerResult({
+            ledgerEntryId: transaction.ledgerEntryId,
+            alreadyProcessed: false,
+        });
+    }
+    async getEntitlementTransaction(ledgerEntryId) {
+        return this.entitlementTransactionsById.get(ledgerEntryId);
+    }
+    async listEntitlementTransactions() {
+        return [...this.entitlementTransactionsById.values()];
+    }
+    async recordLeaderboardScore(input, options = {}) {
+        const request = assertRecordLeaderboardScoreRequest(input);
+        const runKey = createLeaderboardRunKey(request);
+        const existing = this.leaderboardTransactionsByRun.get(runKey);
+        if (existing !== undefined) {
+            return assertRecordLeaderboardScoreResponse({
+                submitted: true,
+                ledgerEntryId: existing.ledgerEntryId,
+                alreadyProcessed: true,
+                rank: this.rankFor(existing),
+            });
+        }
+        const transaction = assertLeaderboardScoreTransaction({
+            ...request,
+            ledgerEntryId: createLeaderboardLedgerEntryId(request),
+            recordedAt: options.recordedAt ?? new Date().toISOString(),
+        });
+        this.leaderboardTransactionsByRun.set(runKey, transaction);
+        this.leaderboardTransactionsById.set(transaction.ledgerEntryId, transaction);
+        return assertRecordLeaderboardScoreResponse({
+            submitted: true,
+            ledgerEntryId: transaction.ledgerEntryId,
+            alreadyProcessed: false,
+            rank: this.rankFor(transaction),
+        });
+    }
+    async getLeaderboardTransaction(ledgerEntryId) {
+        return this.leaderboardTransactionsById.get(ledgerEntryId);
+    }
+    async listLeaderboardTransactions() {
+        return this.sortedLeaderboardTransactions();
+    }
+    rankFor(transaction) {
+        return (this.sortedLeaderboardTransactions()
+            .filter((candidate) => candidate.leaderboardId === transaction.leaderboardId)
+            .findIndex((candidate) => candidate.ledgerEntryId === transaction.ledgerEntryId) + 1);
+    }
+    sortedLeaderboardTransactions() {
+        return [...this.leaderboardTransactionsById.values()].sort((left, right) => {
+            if (right.score !== left.score) {
+                return right.score - left.score;
+            }
+            return left.submittedAt.localeCompare(right.submittedAt);
+        });
+    }
+}
+export function createInMemoryGameServicesStore() {
+    return new InMemoryGameServicesStore();
+}
+export function createGameServicesBackend(input) {
+    const store = input.store ?? createInMemoryGameServicesStore();
+    const now = input.now ?? (() => new Date().toISOString());
+    const version = input.version ?? '0.0.0';
+    const analytics = createAnalyticsReporter({
+        target: 'server',
+        sessionId: input.analyticsSessionId ?? 'game-services',
+        now,
+        ...(input.analytics === undefined ? {} : { sink: input.analytics }),
+    });
+    return {
+        version,
+        purchases: {
+            async verifyPurchase(request) {
+                const verification = await verifyPurchaseWithStore(request, {
+                    catalog: input.catalog,
+                    store,
+                    now,
+                });
+                await analytics.track({
+                    name: verification.verified ? 'purchase_granted' : 'purchase_rejected',
+                    properties: {
+                        target: request.target,
+                        playerId: request.playerId,
+                        productId: request.productId,
+                        ledgerEntryId: verification.ledgerEntryId,
+                        alreadyProcessed: verification.alreadyProcessed,
+                        reason: verification.reason,
+                    },
+                });
+                return verification;
+            },
+        },
+        adRewards: {
+            async claimAdReward(request) {
+                const claim = await claimAdRewardWithStore(request, {
+                    placements: input.placements,
+                    store,
+                    now,
+                });
+                await analytics.track({
+                    name: claim.granted ? 'rewarded_ad_granted' : 'rewarded_ad_rejected',
+                    properties: {
+                        target: request.target,
+                        playerId: request.playerId,
+                        placementId: request.placementId,
+                        ledgerEntryId: claim.ledgerEntryId,
+                        alreadyProcessed: claim.alreadyProcessed,
+                        reason: claim.reason,
+                    },
+                });
+                return claim;
+            },
+        },
+        leaderboard: {
+            async recordScore(request) {
+                const record = await recordLeaderboardScoreWithStore(request, {
+                    store,
+                    now,
+                });
+                await analytics.track({
+                    name: 'leaderboard_recorded',
+                    properties: {
+                        target: request.target,
+                        playerId: request.playerId,
+                        leaderboardId: request.leaderboardId,
+                        score: request.score,
+                        ledgerEntryId: record.ledgerEntryId,
+                        alreadyProcessed: record.alreadyProcessed,
+                        rank: record.rank,
+                    },
+                });
+                return record;
+            },
+        },
+    };
+}
+export function createGameServicesBackendApiHandler(input) {
+    const backend = createGameServicesBackend(input);
+    return {
+        ...(backend.version === undefined ? {} : { version: backend.version }),
+        async handle(request) {
+            if (request.method !== 'POST') {
+                return errorResponse(405, 'METHOD_NOT_ALLOWED');
+            }
+            try {
+                return await routeGameServicesRequest(request.endpoint, request.body, backend);
+            }
+            catch (error) {
+                return errorResponse(400, error instanceof Error ? error.message : 'BAD_REQUEST');
+            }
+        },
+    };
+}
+export function createInProcessGameServicesBackendTransport(handler) {
+    return {
+        async send(request) {
+            return handler.handle(request);
+        },
+    };
+}
+export function createGameServicesRouter(backend) {
+    const contract = implement(gameServicesContract).$context();
+    return contract.router({
+        health: contract.health.handler(() => createHealthResponse(backend.version)),
+        commerce: contract.commerce.router({
+            verifyPurchase: contract.commerce.verifyPurchase.handler(({ input }) => {
+                return backend.purchases.verifyPurchase(input);
+            }),
+        }),
+        ads: contract.ads.router({
+            claimReward: contract.ads.claimReward.handler(({ input }) => {
+                return backend.adRewards.claimAdReward(input);
+            }),
+        }),
+        leaderboard: contract.leaderboard.router({
+            recordScore: contract.leaderboard.recordScore.handler(({ input }) => {
+                return backend.leaderboard.recordScore(input);
+            }),
+        }),
+    });
+}
+export function createGameServicesRpcFetchHandler(router, options = {}) {
+    const rpcHandler = new RPCHandler(router);
+    const prefix = options.prefix ?? '/rpc';
+    const healthPath = options.healthPath ?? '/health';
+    return async (request) => {
+        const requestUrl = new URL(request.url);
+        if (requestUrl.pathname === healthPath) {
+            return jsonResponse(createHealthResponse(options.version), 200, options.corsHeaders);
+        }
+        if (request.method === 'OPTIONS') {
+            return emptyResponse(204, options.corsHeaders);
+        }
+        const result = await rpcHandler.handle(request, {
+            prefix,
+            context: {
+                request,
+            },
+        });
+        if (!result.matched) {
+            return textResponse('Not Found', 404, options.corsHeaders);
+        }
+        return withCors(result.response, options.corsHeaders);
+    };
+}
+export function createGameServicesHttpFetchHandler(handler, options = {}) {
+    const healthPath = options.healthPath ?? '/health';
+    return async (request) => {
+        const requestUrl = new URL(request.url);
+        if (requestUrl.pathname === healthPath) {
+            return jsonResponse(createHealthResponse(options.version ?? handler.version), 200, options.corsHeaders);
+        }
+        if (request.method === 'OPTIONS') {
+            return emptyResponse(204, options.corsHeaders);
+        }
+        if (request.method !== 'POST') {
+            return jsonResponse({ error: 'METHOD_NOT_ALLOWED' }, 405, options.corsHeaders);
+        }
+        if (!isGameServicesBackendEndpoint(requestUrl.pathname)) {
+            return jsonResponse({ error: 'UNKNOWN_ENDPOINT' }, 404, options.corsHeaders);
+        }
+        try {
+            const response = await handler.handle({
+                method: 'POST',
+                endpoint: requestUrl.pathname,
+                body: await readRequestJson(request),
+            });
+            return jsonResponse(response.body, response.status, options.corsHeaders);
+        }
+        catch (error) {
+            return jsonResponse({ error: error instanceof Error ? error.message : 'BAD_REQUEST' }, 400, options.corsHeaders);
+        }
+    };
+}
+async function verifyPurchaseWithStore(input, context) {
+    const request = assertVerifyPurchaseRequest(input);
+    const product = context.catalog.products.find((entry) => entry.id === request.productId);
+    if (product === undefined) {
+        return assertVerifyPurchaseResponse({
+            verified: false,
+            alreadyProcessed: false,
+            reason: 'UNKNOWN_PRODUCT',
+        });
+    }
+    const platformProductId = product.platformProductIds[request.target];
+    if (platformProductId === undefined) {
+        return assertVerifyPurchaseResponse({
+            verified: false,
+            alreadyProcessed: false,
+            reason: 'PRODUCT_NOT_AVAILABLE_ON_TARGET',
+        });
+    }
+    const grant = await context.store.recordEntitlementGrant({
+        playerId: request.playerId,
+        grantId: product.id,
+        source: 'purchase',
+        idempotencyKey: request.idempotencyKey,
+        grantedAt: context.now(),
+        grant: product.grant,
+        payload: {
+            target: request.target,
+            productId: request.productId,
+            platformProductId,
+            platformTransactionId: request.platformTransactionId,
+            purchasedAt: request.purchasedAt,
+        },
+    });
+    return assertVerifyPurchaseResponse({
+        verified: true,
+        ledgerEntryId: grant.ledgerEntryId,
+        alreadyProcessed: grant.alreadyProcessed,
+    });
+}
+async function claimAdRewardWithStore(input, context) {
+    const request = assertClaimAdRewardRequest(input);
+    const placement = context.placements.placements.find((entry) => entry.id === request.placementId);
+    if (placement === undefined || placement.type !== 'rewarded' || placement.reward === undefined) {
+        return assertClaimAdRewardResponse({
+            granted: false,
+            alreadyProcessed: false,
+            reason: placement === undefined ? 'UNKNOWN_PLACEMENT' : 'NOT_REWARDED_PLACEMENT',
+        });
+    }
+    const payload = {
+        target: request.target,
+        placementId: request.placementId,
+        rewardType: placement.reward.type,
+        amount: placement.reward.amount,
+        completedAt: request.completedAt,
+    };
+    if (placement.reward.type === 'currency') {
+        payload.currency = placement.reward.currency;
+    }
+    if (request.platformImpressionId !== undefined) {
+        payload.platformImpressionId = request.platformImpressionId;
+    }
+    const result = await context.store.recordEntitlementGrant({
+        playerId: request.playerId,
+        grantId: request.placementId,
+        source: 'ad_reward',
+        idempotencyKey: request.idempotencyKey,
+        grantedAt: context.now(),
+        payload,
+    });
+    return assertClaimAdRewardResponse({
+        granted: true,
+        ledgerEntryId: result.ledgerEntryId,
+        alreadyProcessed: result.alreadyProcessed,
+    });
+}
+async function recordLeaderboardScoreWithStore(input, context) {
+    return context.store.recordLeaderboardScore(assertRecordLeaderboardScoreRequest(input), {
+        recordedAt: context.now(),
+    });
+}
+async function routeGameServicesRequest(endpoint, body, backend) {
+    switch (endpoint) {
+        case gameServicesBackendEndpoints.verifyPurchase:
+            return okResponse(await backend.purchases.verifyPurchase(body));
+        case gameServicesBackendEndpoints.claimAdReward:
+            return okResponse(await backend.adRewards.claimAdReward(body));
+        case gameServicesBackendEndpoints.recordLeaderboardScore:
+            return okResponse(await backend.leaderboard.recordScore(body));
+    }
+    return errorResponse(404, 'UNKNOWN_ENDPOINT');
+}
+function okResponse(body) {
+    return {
+        status: 200,
+        body,
+    };
+}
+function errorResponse(status, error) {
+    return {
+        status,
+        body: {
+            error,
+        },
+    };
+}
+function createHealthResponse(version = '0.0.0') {
+    return {
+        ok: true,
+        service: 'game-services',
+        version,
+    };
+}
+function createEntitlementTransaction(grant) {
+    const baseTransaction = {
+        ledgerEntryId: createEntitlementLedgerEntryId(grant),
+        playerId: grant.playerId,
+        grantId: grant.grantId,
+        source: grant.source,
+        idempotencyKey: grant.idempotencyKey,
+        grantedAt: grant.grantedAt,
+        payload: grant.payload,
+    };
+    return assertProductGrantTransaction(grant.grant === undefined ? baseTransaction : { ...baseTransaction, grant: grant.grant });
+}
+function createEntitlementIdempotencyKey(grant) {
+    return createCompositeKey([grant.source, grant.playerId, grant.idempotencyKey]);
+}
+function createEntitlementLedgerEntryId(grant) {
+    return [
+        'ledger',
+        encodeIdSegment(grant.source),
+        encodeIdSegment(grant.playerId),
+        encodeIdSegment(grant.idempotencyKey),
+    ].join('_');
+}
+function createLeaderboardRunKey(request) {
+    return createCompositeKey([
+        request.target,
+        request.leaderboardId,
+        request.playerId,
+        request.runId,
+    ]);
+}
+function createLeaderboardLedgerEntryId(request) {
+    return [
+        'leaderboard',
+        encodeIdSegment(request.target),
+        encodeIdSegment(request.leaderboardId),
+        encodeIdSegment(request.playerId),
+        encodeIdSegment(request.runId),
+    ].join('_');
+}
+function createCompositeKey(parts) {
+    return JSON.stringify(parts);
+}
+function encodeIdSegment(value) {
+    return `${value.length}:${encodeURIComponent(value)}`;
+}
+function isGameServicesBackendEndpoint(pathname) {
+    return Object.values(gameServicesBackendEndpoints).includes(pathname);
+}
+async function readRequestJson(request) {
+    const text = await request.text();
+    if (text.length === 0) {
+        return {};
+    }
+    return JSON.parse(text);
+}
+function jsonResponse(body, status, corsHeaders) {
+    const headers = new Headers({
+        'content-type': 'application/json; charset=utf-8',
+    });
+    applyCorsHeaders(headers, corsHeaders);
+    return new Response(JSON.stringify(body), {
+        status,
+        headers,
+    });
+}
+function textResponse(body, status, corsHeaders) {
+    const headers = new Headers();
+    applyCorsHeaders(headers, corsHeaders);
+    return new Response(body, {
+        status,
+        headers,
+    });
+}
+function emptyResponse(status, corsHeaders) {
+    const headers = new Headers();
+    applyCorsHeaders(headers, corsHeaders);
+    return new Response(null, {
+        status,
+        headers,
+    });
+}
+function withCors(response, corsHeaders) {
+    if (corsHeaders === undefined) {
+        return response;
+    }
+    const headers = new Headers(response.headers);
+    applyCorsHeaders(headers, corsHeaders);
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+function applyCorsHeaders(headers, corsHeaders) {
+    if (corsHeaders === undefined) {
+        return;
+    }
+    for (const [key, value] of Object.entries(corsHeaders)) {
+        headers.set(key, value);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,85 @@
+import type { ProductGrant } from '@mpgd/catalog';
+import type { LeaderboardScoreInput, LogicalAdPlacementId, LogicalProductId, PlatformTarget } from '@mpgd/platform';
+export type GameServicesStoreTarget = Extract<PlatformTarget, 'android' | 'ios' | 'ait'>;
+export type GameServicesLedgerTarget = Extract<PlatformTarget, 'browser' | 'android' | 'ios' | 'ait'>;
+export type PurchaseIdempotencyKey = string;
+export type AdRewardIdempotencyKey = string;
+export type EntitlementIdempotencyKey = PurchaseIdempotencyKey | AdRewardIdempotencyKey;
+export type EntitlementLedgerSource = 'purchase' | 'ad_reward' | 'admin';
+export type EntitlementLedgerPayload = Record<string, string | number | boolean>;
+export interface VerifyPurchaseRequest {
+  readonly target: GameServicesStoreTarget;
+  readonly playerId: string;
+  readonly productId: LogicalProductId;
+  readonly platformTransactionId: string;
+  readonly idempotencyKey: PurchaseIdempotencyKey;
+  readonly purchasedAt: string;
+}
+export interface VerifyPurchaseResponse {
+  readonly verified: boolean;
+  readonly ledgerEntryId?: string;
+  readonly alreadyProcessed: boolean;
+  readonly reason?: string;
+}
+export interface ClaimAdRewardRequest {
+  readonly target: GameServicesStoreTarget;
+  readonly playerId: string;
+  readonly placementId: LogicalAdPlacementId;
+  readonly platformImpressionId?: string;
+  readonly idempotencyKey: AdRewardIdempotencyKey;
+  readonly completedAt: string;
+}
+export interface ClaimAdRewardResponse {
+  readonly granted: boolean;
+  readonly ledgerEntryId?: string;
+  readonly alreadyProcessed: boolean;
+  readonly reason?: 'UNKNOWN_PLACEMENT' | 'NOT_REWARDED_PLACEMENT';
+}
+export interface RecordLeaderboardScoreRequest extends LeaderboardScoreInput {
+  readonly target: GameServicesLedgerTarget;
+  readonly playerId: string;
+  readonly platformSubmissionId?: string;
+}
+export interface RecordLeaderboardScoreResponse {
+  readonly submitted: boolean;
+  readonly ledgerEntryId: string;
+  readonly alreadyProcessed: boolean;
+  readonly rank: number;
+}
+export interface EntitlementLedgerGrant {
+  readonly playerId: string;
+  readonly grantId: string;
+  readonly source: EntitlementLedgerSource;
+  readonly idempotencyKey: EntitlementIdempotencyKey;
+  readonly grantedAt: string;
+  readonly grant?: ProductGrant;
+  readonly payload: EntitlementLedgerPayload;
+}
+export interface EntitlementLedgerResult {
+  readonly ledgerEntryId: string;
+  readonly alreadyProcessed: boolean;
+}
+export interface ProductGrantTransaction {
+  readonly ledgerEntryId: string;
+  readonly playerId: string;
+  readonly grantId: string;
+  readonly source: EntitlementLedgerSource;
+  readonly idempotencyKey: EntitlementIdempotencyKey;
+  readonly grantedAt: string;
+  readonly grant?: ProductGrant;
+  readonly payload: EntitlementLedgerPayload;
+}
+export interface LeaderboardScoreTransaction extends RecordLeaderboardScoreRequest {
+  readonly ledgerEntryId: string;
+  readonly recordedAt: string;
+}
+export declare function assertVerifyPurchaseRequest(input: VerifyPurchaseRequest): VerifyPurchaseRequest;
+export declare function assertVerifyPurchaseResponse(input: VerifyPurchaseResponse): VerifyPurchaseResponse;
+export declare function assertClaimAdRewardRequest(input: ClaimAdRewardRequest): ClaimAdRewardRequest;
+export declare function assertClaimAdRewardResponse(input: ClaimAdRewardResponse): ClaimAdRewardResponse;
+export declare function assertRecordLeaderboardScoreRequest(input: RecordLeaderboardScoreRequest): RecordLeaderboardScoreRequest;
+export declare function assertRecordLeaderboardScoreResponse(input: RecordLeaderboardScoreResponse): RecordLeaderboardScoreResponse;
+export declare function assertEntitlementLedgerGrant(input: EntitlementLedgerGrant): EntitlementLedgerGrant;
+export declare function assertEntitlementLedgerResult(input: EntitlementLedgerResult): EntitlementLedgerResult;
+export declare function assertProductGrantTransaction(input: ProductGrantTransaction): ProductGrantTransaction;
+export declare function assertLeaderboardScoreTransaction(input: LeaderboardScoreTransaction): LeaderboardScoreTransaction;

package/dist/types.js

@@ -0,0 +1,165 @@
+export function assertVerifyPurchaseRequest(input) {
+    assertRecord(input, 'VerifyPurchaseRequest');
+    assertStoreTarget(input.target);
+    assertNonEmptyString(input.playerId, 'playerId');
+    assertNonEmptyString(input.productId, 'productId');
+    assertNonEmptyString(input.platformTransactionId, 'platformTransactionId');
+    assertNonEmptyString(input.idempotencyKey, 'idempotencyKey');
+    assertNonEmptyString(input.purchasedAt, 'purchasedAt');
+    return input;
+}
+export function assertVerifyPurchaseResponse(input) {
+    assertRecord(input, 'VerifyPurchaseResponse');
+    assertBoolean(input.verified, 'verified');
+    assertOptionalNonEmptyString(input.ledgerEntryId, 'ledgerEntryId');
+    assertBoolean(input.alreadyProcessed, 'alreadyProcessed');
+    assertOptionalNonEmptyString(input.reason, 'reason');
+    return input;
+}
+export function assertClaimAdRewardRequest(input) {
+    assertRecord(input, 'ClaimAdRewardRequest');
+    assertStoreTarget(input.target);
+    assertNonEmptyString(input.playerId, 'playerId');
+    assertNonEmptyString(input.placementId, 'placementId');
+    assertOptionalNonEmptyString(input.platformImpressionId, 'platformImpressionId');
+    assertNonEmptyString(input.idempotencyKey, 'idempotencyKey');
+    assertNonEmptyString(input.completedAt, 'completedAt');
+    return input;
+}
+export function assertClaimAdRewardResponse(input) {
+    assertRecord(input, 'ClaimAdRewardResponse');
+    assertBoolean(input.granted, 'granted');
+    assertOptionalNonEmptyString(input.ledgerEntryId, 'ledgerEntryId');
+    assertBoolean(input.alreadyProcessed, 'alreadyProcessed');
+    assertOptionalAdRewardReason(input.reason, 'reason');
+    return input;
+}
+export function assertRecordLeaderboardScoreRequest(input) {
+    assertRecord(input, 'RecordLeaderboardScoreRequest');
+    assertLeaderboardTarget(input.target);
+    assertNonEmptyString(input.playerId, 'playerId');
+    assertNonEmptyString(input.leaderboardId, 'leaderboardId');
+    assertFiniteNumber(input.score, 'score');
+    assertNonEmptyString(input.runId, 'runId');
+    assertNonEmptyString(input.submittedAt, 'submittedAt');
+    assertOptionalNonEmptyString(input.platformSubmissionId, 'platformSubmissionId');
+    return input;
+}
+export function assertRecordLeaderboardScoreResponse(input) {
+    assertRecord(input, 'RecordLeaderboardScoreResponse');
+    assertBoolean(input.submitted, 'submitted');
+    assertNonEmptyString(input.ledgerEntryId, 'ledgerEntryId');
+    assertBoolean(input.alreadyProcessed, 'alreadyProcessed');
+    assertFiniteNumber(input.rank, 'rank');
+    return input;
+}
+export function assertEntitlementLedgerGrant(input) {
+    assertRecord(input, 'EntitlementLedgerGrant');
+    assertNonEmptyString(input.playerId, 'playerId');
+    assertNonEmptyString(input.grantId, 'grantId');
+    assertLedgerSource(input.source);
+    assertNonEmptyString(input.idempotencyKey, 'idempotencyKey');
+    assertNonEmptyString(input.grantedAt, 'grantedAt');
+    if (input.grant !== undefined) {
+        assertProductGrant(input.grant);
+    }
+    assertPayload(input.payload);
+    return input;
+}
+export function assertEntitlementLedgerResult(input) {
+    assertRecord(input, 'EntitlementLedgerResult');
+    assertNonEmptyString(input.ledgerEntryId, 'ledgerEntryId');
+    assertBoolean(input.alreadyProcessed, 'alreadyProcessed');
+    return input;
+}
+export function assertProductGrantTransaction(input) {
+    assertRecord(input, 'ProductGrantTransaction');
+    assertNonEmptyString(input.ledgerEntryId, 'ledgerEntryId');
+    assertNonEmptyString(input.playerId, 'playerId');
+    assertNonEmptyString(input.grantId, 'grantId');
+    assertLedgerSource(input.source);
+    assertNonEmptyString(input.idempotencyKey, 'idempotencyKey');
+    assertNonEmptyString(input.grantedAt, 'grantedAt');
+    if (input.grant !== undefined) {
+        assertProductGrant(input.grant);
+    }
+    assertPayload(input.payload);
+    return input;
+}
+export function assertLeaderboardScoreTransaction(input) {
+    assertRecordLeaderboardScoreRequest(input);
+    assertNonEmptyString(input.ledgerEntryId, 'ledgerEntryId');
+    assertNonEmptyString(input.recordedAt, 'recordedAt');
+    return input;
+}
+function assertRecord(input, label) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new Error(`${label} must be an object.`);
+    }
+}
+function assertStoreTarget(input) {
+    if (input !== 'android' && input !== 'ios' && input !== 'ait') {
+        throw new Error('target must be android, ios, or ait.');
+    }
+}
+function assertLeaderboardTarget(input) {
+    if (input !== 'browser' && input !== 'android' && input !== 'ios' && input !== 'ait') {
+        throw new Error('target must be browser, android, ios, or ait.');
+    }
+}
+function assertNonEmptyString(input, label) {
+    if (typeof input !== 'string' || input.length === 0) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+}
+function assertOptionalNonEmptyString(input, label) {
+    if (input !== undefined) {
+        assertNonEmptyString(input, label);
+    }
+}
+function assertFiniteNumber(input, label) {
+    if (typeof input !== 'number' || !Number.isFinite(input)) {
+        throw new Error(`${label} must be a finite number.`);
+    }
+}
+function assertBoolean(input, label) {
+    if (typeof input !== 'boolean') {
+        throw new Error(`${label} must be a boolean.`);
+    }
+}
+function assertLedgerSource(input) {
+    if (input !== 'purchase' && input !== 'ad_reward' && input !== 'admin') {
+        throw new Error('source must be purchase, ad_reward, or admin.');
+    }
+}
+function assertProductGrant(input) {
+    assertRecord(input, 'grant');
+    if (input.type === 'currency') {
+        if (input.currency !== 'coin' && input.currency !== 'gem') {
+            throw new Error('grant.currency must be coin or gem.');
+        }
+        assertFiniteNumber(input.amount, 'grant.amount');
+        return;
+    }
+    if (input.type === 'entitlement') {
+        assertNonEmptyString(input.entitlement, 'grant.entitlement');
+        return;
+    }
+    throw new Error('grant.type must be currency or entitlement.');
+}
+function assertOptionalAdRewardReason(input, label) {
+    if (input !== undefined
+        && input !== 'UNKNOWN_PLACEMENT'
+        && input !== 'NOT_REWARDED_PLACEMENT') {
+        throw new Error(`${label} must be UNKNOWN_PLACEMENT or NOT_REWARDED_PLACEMENT.`);
+    }
+}
+function assertPayload(input) {
+    assertRecord(input, 'payload');
+    for (const [key, value] of Object.entries(input)) {
+        const valueType = typeof value;
+        if (valueType !== 'string' && valueType !== 'number' && valueType !== 'boolean') {
+            throw new Error(`payload.${key} must be a string, number, or boolean.`);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@mpgd/game-services",
+  "version": "0.1.0",
+  "description": "Client, contract, server, store, and test helpers for authoritative mpgd game services.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/imjlk/mpgd-kit.git",
+    "directory": "packages/game-services"
+  },
+  "bugs": {
+    "url": "https://github.com/imjlk/mpgd-kit/issues"
+  },
+  "homepage": "https://github.com/imjlk/mpgd-kit#readme",
+  "keywords": [
+    "mpgd",
+    "phaser",
+    "vite",
+    "typescript",
+    "capacitor",
+    "apps-in-toss",
+    "game-development",
+    "game-distribution"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "default": "./dist/client.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "default": "./dist/contract.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@orpc/client": "2.0.0-beta.14",
+    "@orpc/contract": "2.0.0-beta.14",
+    "@orpc/server": "2.0.0-beta.14",
+    "@mpgd/analytics": "0.1.0",
+    "@mpgd/catalog": "0.1.0",
+    "@mpgd/platform": "0.1.0"
+  },
+  "devDependencies": {
+    "ttsc": "0.16.9",
+    "typescript": "7.0.1-rc"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check": "ttsc --noEmit",
+    "lint": "ttsc --noEmit",
+    "format": "ttsc format",
+    "fix": "ttsc fix",
+    "test": "cd ../.. && node tools/run-ttsx.mjs packages/game-services/src/client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/server.test.ts"
+  }
+}