@mpgd/bridge 0.3.2 → 0.4.0

package/dist/cloudflare-pages.d.ts

@@ -0,0 +1,42 @@
+import { type BridgeRequest, type BridgeResponse } from './index';
+import { type BridgeRpcPrefix } from './orpc';
+export declare const defaultCloudflarePagesBridgeEndpoint: '/api/mpgd/bridge';
+export declare const defaultCloudflarePagesGameServicesPrefix: '/api/game-services';
+export declare const defaultCloudflarePagesGameServicesForwardHeaders: readonly ['accept', 'authorization', 'content-type'];
+export declare const defaultCloudflarePagesCorsHeaders: {
+  readonly 'access-control-allow-origin': '*';
+  readonly 'access-control-allow-methods': 'GET, POST, OPTIONS';
+  readonly 'access-control-allow-headers': 'content-type, authorization';
+};
+type CorsHeaders = Record<string, string>;
+export interface CloudflarePagesAssetsBinding {
+  fetch(request: Request): Promise<Response>;
+}
+export interface CloudflarePagesServiceBinding {
+  fetch(request: Request): Promise<Response>;
+}
+export interface MpgdCloudflarePagesHostEnv {
+  readonly ASSETS: CloudflarePagesAssetsBinding;
+  readonly GAME_SERVICES?: CloudflarePagesServiceBinding;
+}
+export interface MpgdCloudflarePagesHostContext {
+  waitUntil(promise: Promise<unknown>): void;
+}
+export type MpgdCloudflarePagesBridgeHandler<TEnv extends MpgdCloudflarePagesHostEnv = MpgdCloudflarePagesHostEnv> = (input: MpgdCloudflarePagesBridgeHandlerInput<TEnv>) => BridgeResponse | Promise<BridgeResponse>;
+export interface MpgdCloudflarePagesBridgeHandlerInput<TEnv extends MpgdCloudflarePagesHostEnv = MpgdCloudflarePagesHostEnv> {
+  readonly request: Request;
+  readonly env: TEnv;
+  readonly ctx: MpgdCloudflarePagesHostContext | undefined;
+  readonly bridgeRequest: BridgeRequest;
+}
+export interface CreateMpgdCloudflarePagesHostFetchHandlerOptions<TEnv extends MpgdCloudflarePagesHostEnv = MpgdCloudflarePagesHostEnv> {
+  readonly bridgeEndpoint?: string;
+  readonly bridgeRpcEndpoint?: BridgeRpcPrefix;
+  readonly bridgeHandler?: MpgdCloudflarePagesBridgeHandler<TEnv>;
+  readonly gameServicesPrefix?: string;
+  readonly gameServicesForwardHeaders?: readonly string[] | 'all';
+  readonly corsHeaders?: CorsHeaders | false;
+}
+export declare function createMpgdCloudflarePagesHostFetchHandler<TEnv extends MpgdCloudflarePagesHostEnv = MpgdCloudflarePagesHostEnv>(options?: CreateMpgdCloudflarePagesHostFetchHandlerOptions<TEnv>): (request: Request, env: TEnv, ctx?: MpgdCloudflarePagesHostContext) => Promise<Response>;
+export declare function createMpgdCloudflarePagesBridgeHandler<TEnv extends MpgdCloudflarePagesHostEnv = MpgdCloudflarePagesHostEnv>(): MpgdCloudflarePagesBridgeHandler<TEnv>;
+export {};

package/dist/cloudflare-pages.js

@@ -0,0 +1,252 @@
+import { assertBridgeRequest, createBridgeError, } from './index';
+import { createBridgeRpcFetchHandler, createBridgeRpcRouter, defaultBridgeRpcEndpoint, } from './orpc';
+export const defaultCloudflarePagesBridgeEndpoint = '/api/mpgd/bridge';
+export const defaultCloudflarePagesGameServicesPrefix = '/api/game-services';
+export const defaultCloudflarePagesGameServicesForwardHeaders = [
+    'accept',
+    'authorization',
+    'content-type',
+];
+export const defaultCloudflarePagesCorsHeaders = {
+    'access-control-allow-origin': '*',
+    'access-control-allow-methods': 'GET, POST, OPTIONS',
+    'access-control-allow-headers': 'content-type, authorization',
+};
+export function createMpgdCloudflarePagesHostFetchHandler(options = {}) {
+    const bridgeEndpoint = options.bridgeEndpoint ?? defaultCloudflarePagesBridgeEndpoint;
+    const bridgeRpcEndpoint = options.bridgeRpcEndpoint ?? defaultBridgeRpcEndpoint;
+    const gameServicesPrefix = options.gameServicesPrefix ?? defaultCloudflarePagesGameServicesPrefix;
+    const gameServicesForwardHeaders = options.gameServicesForwardHeaders ?? defaultCloudflarePagesGameServicesForwardHeaders;
+    const bridgeHandler = options.bridgeHandler ?? createMpgdCloudflarePagesBridgeHandler();
+    const corsHeaders = options.corsHeaders === false
+        ? undefined
+        : (options.corsHeaders ?? defaultCloudflarePagesCorsHeaders);
+    return async (request, env, ctx) => {
+        const url = new URL(request.url);
+        try {
+            if (request.method === 'OPTIONS' &&
+                corsHeaders !== undefined &&
+                (url.pathname === bridgeEndpoint ||
+                    isPathUnderPrefix(url.pathname, bridgeRpcEndpoint) ||
+                    isPathUnderPrefix(url.pathname, gameServicesPrefix))) {
+                return emptyResponse(204, corsHeaders);
+            }
+            if (url.pathname === bridgeEndpoint) {
+                return handleBridgeJsonRequest(request, env, ctx, bridgeHandler, corsHeaders);
+            }
+            if (isPathUnderPrefix(url.pathname, bridgeRpcEndpoint)) {
+                const rpcFetch = createBridgeRpcFetchHandler(createBridgeRpcRouter((bridgeRequest) => {
+                    return bridgeHandler({
+                        request,
+                        env,
+                        ctx,
+                        bridgeRequest,
+                    });
+                }), {
+                    prefix: bridgeRpcEndpoint,
+                });
+                return withCors(await rpcFetch(request), corsHeaders);
+            }
+            if (isPathUnderPrefix(url.pathname, gameServicesPrefix)) {
+                return proxyGameServicesRequest(request, env, gameServicesPrefix, corsHeaders, gameServicesForwardHeaders);
+            }
+            return env.ASSETS.fetch(request);
+        }
+        catch (error) {
+            console.error(JSON.stringify({
+                message: 'mpgd Cloudflare Pages host request failed',
+                path: url.pathname,
+                error: errorMessage(error),
+            }));
+            return jsonResponse({ error: 'MPGD_PAGES_HOST_INTERNAL_ERROR' }, 500, corsHeaders);
+        }
+    };
+}
+export function createMpgdCloudflarePagesBridgeHandler() {
+    return async (input) => {
+        switch (input.bridgeRequest.method) {
+            case 'runtime.getCapabilities':
+                return ok(input.bridgeRequest, {
+                    nativeIap: false,
+                    nativeAds: false,
+                    rewardedAds: false,
+                    interstitialAds: false,
+                    nativeLeaderboard: false,
+                    achievements: false,
+                    cloudSave: false,
+                    socialShare: true,
+                    haptics: false,
+                    localizedContent: true,
+                });
+            case 'identity.getPlayer': {
+                return ok(input.bridgeRequest, null);
+            }
+            case 'commerce.getProducts':
+            case 'commerce.getEntitlements':
+                return ok(input.bridgeRequest, []);
+            case 'commerce.purchase':
+                return ok(input.bridgeRequest, {
+                    status: 'cancelled',
+                    entitlementIds: [],
+                });
+            case 'commerce.restore':
+                return ok(input.bridgeRequest, {
+                    restoredEntitlements: [],
+                });
+            case 'ads.preload':
+                return ok(input.bridgeRequest, {});
+            case 'ads.showRewarded':
+                return ok(input.bridgeRequest, {
+                    status: 'unavailable',
+                    rewardGranted: false,
+                });
+            case 'ads.showInterstitial':
+                return ok(input.bridgeRequest, {
+                    status: 'unavailable',
+                });
+            case 'leaderboard.submitScore':
+                return ok(input.bridgeRequest, {
+                    submitted: false,
+                });
+            case 'leaderboard.open':
+                return createBridgeError(input.bridgeRequest.id, 'CLOUDFLARE_PAGES_LEADERBOARD_OPEN_UNAVAILABLE', 'Cloudflare Pages host does not provide a native leaderboard UI.');
+            case 'storage.load':
+                return ok(input.bridgeRequest, null);
+            case 'storage.save':
+                return ok(input.bridgeRequest, {
+                    saved: false,
+                });
+            default:
+                return createBridgeError(input.bridgeRequest.id, 'UNSUPPORTED_METHOD', `Unsupported Cloudflare Pages bridge method: ${input.bridgeRequest.method}`);
+        }
+    };
+}
+async function handleBridgeJsonRequest(request, env, ctx, bridgeHandler, corsHeaders) {
+    if (request.method === 'OPTIONS') {
+        return emptyResponse(204, corsHeaders);
+    }
+    if (request.method !== 'POST') {
+        return jsonResponse({ error: 'METHOD_NOT_ALLOWED' }, 405, corsHeaders);
+    }
+    let bridgeRequest;
+    try {
+        bridgeRequest = assertBridgeRequest(await request.json());
+    }
+    catch (error) {
+        return jsonResponse(createBridgeError('unknown', 'INVALID_BRIDGE_REQUEST', `Bridge request failed runtime validation: ${errorMessage(error)}`), 400, corsHeaders);
+    }
+    try {
+        return jsonResponse(await bridgeHandler({
+            request,
+            env,
+            ctx,
+            bridgeRequest,
+        }), 200, corsHeaders);
+    }
+    catch (error) {
+        console.error(JSON.stringify({
+            message: 'Cloudflare Pages bridge handler failed',
+            bridgeRequestId: bridgeRequest.id,
+            error: errorMessage(error),
+        }));
+        return jsonResponse(createBridgeError(bridgeRequest.id, 'BRIDGE_HANDLER_ERROR', 'An internal error occurred while processing the bridge request.', true), 500, corsHeaders);
+    }
+}
+async function proxyGameServicesRequest(request, env, prefix, corsHeaders, forwardHeaders) {
+    if (env.GAME_SERVICES === undefined) {
+        return jsonResponse({ error: 'GAME_SERVICES_BINDING_UNAVAILABLE' }, 503, corsHeaders);
+    }
+    const url = new URL(request.url);
+    const pathname = url.pathname.slice(prefix.length);
+    if (hasParentPathSegment(pathname)) {
+        return jsonResponse({ error: 'INVALID_GAME_SERVICES_PATH' }, 400, corsHeaders);
+    }
+    url.pathname = pathname.length === 0 ? '/' : pathname;
+    return withCors(await env.GAME_SERVICES.fetch(await createForwardedRequest(request, url, forwardHeaders)), corsHeaders);
+}
+function isPathUnderPrefix(pathname, prefix) {
+    return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function ok(input, data) {
+    return {
+        id: input.id,
+        ok: true,
+        data,
+    };
+}
+function hasParentPathSegment(pathname) {
+    return pathname.split('/').some((segment) => {
+        return decodePathSegment(segment).split('/').includes('..');
+    });
+}
+function decodePathSegment(segment) {
+    let decoded = segment;
+    for (let index = 0; index < 64; index += 1) {
+        try {
+            const next = decodeURIComponent(decoded);
+            if (next === decoded) {
+                return decoded;
+            }
+            decoded = next;
+        }
+        catch {
+            return '..';
+        }
+    }
+    return '..';
+}
+async function createForwardedRequest(request, url, forwardHeaders) {
+    const headers = forwardHeaders === 'all'
+        ? request.headers
+        : createForwardedHeaders(request.headers, forwardHeaders);
+    const init = {
+        method: request.method,
+        headers,
+    };
+    if (request.method !== 'GET' && request.method !== 'HEAD') {
+        init.body = await request.arrayBuffer();
+    }
+    return new Request(url.toString(), init);
+}
+function createForwardedHeaders(headers, forwardHeaders) {
+    const forwarded = new Headers();
+    for (const name of forwardHeaders) {
+        const value = headers.get(name);
+        if (value !== null) {
+            forwarded.set(name, value);
+        }
+    }
+    return forwarded;
+}
+function emptyResponse(status, corsHeaders) {
+    return new Response(null, {
+        status,
+        ...(corsHeaders === undefined ? {} : { headers: corsHeaders }),
+    });
+}
+function jsonResponse(body, status, corsHeaders) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: {
+            'content-type': 'application/json',
+            ...(corsHeaders ?? {}),
+        },
+    });
+}
+function withCors(response, corsHeaders) {
+    if (corsHeaders === undefined) {
+        return response;
+    }
+    const headers = new Headers(response.headers);
+    for (const [key, value] of Object.entries(corsHeaders)) {
+        headers.set(key, value);
+    }
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/bridge",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Typed native bridge protocol for mpgd platform adapters.",
   "license": "MIT",
   "repository": {
@@ -32,6 +32,10 @@
     "./orpc": {
       "types": "./dist/orpc.d.ts",
       "default": "./dist/orpc.js"
+    },
+    "./cloudflare-pages": {
+      "types": "./dist/cloudflare-pages.d.ts",
+      "default": "./dist/cloudflare-pages.js"
     }
   },
   "files": [
@@ -57,6 +61,6 @@
     "lint": "ttsc --noEmit",
     "format": "ttsc format",
     "fix": "ttsc fix",
-    "test": "cd ../.. && node tools/run-ttsx.mjs packages/bridge/src/bridge-protocol.test.ts && node tools/run-ttsx.mjs packages/bridge/src/orpc.test.ts"
+    "test": "cd ../.. && node tools/run-ttsx.mjs packages/bridge/src/bridge-protocol.test.ts && node tools/run-ttsx.mjs packages/bridge/src/orpc.test.ts && node tools/run-ttsx.mjs packages/bridge/src/cloudflare-pages.test.ts"
   }
 }