@ripple-ts/adapter 0.2.214 → 0.2.216

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @ripple-ts/adapter
 
+## 0.2.216
+
+## 0.2.215
+
 ## 0.2.214
 
 ## 0.2.213

package/package.json

@@ -3,7 +3,7 @@
   "description": "Shared adapter primitives for Ripple metaframework adapters",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.2.214",
+  "version": "0.2.216",
   "type": "module",
   "module": "src/index.js",
   "main": "src/index.js",

package/src/rpc.js

@@ -65,12 +65,15 @@ export function patch_global_fetch(async_context) {
 	// This prevents layered wrapping when createHandler() or getDevAsyncContext()
 	// is called more than once in the same process (tests, hot reload, etc.).
 	if (/** @type {RipplePatchedFetch} */ (globalThis.fetch).__ripple_patched) {
-		return () => {};
+		return { restore() {}, set_handler(/** @type {any} */ _h) {} };
 	}
 
 	/** @type {typeof globalThis.fetch} */
 	const original_fetch = globalThis.fetch;
 
+	/** @type {((request: Request) => Promise<Response>) | null} */
+	let internal_handler = null;
+
 	/**
 	 * @param {string | Request | URL} input
 	 * @param {RequestInit} [init]
@@ -93,6 +96,26 @@ export function patch_global_fetch(async_context) {
 					input = new URL(relative, context.origin);
 				}
 			}
+
+			// Short-circuit same-origin requests: route them directly through
+			// the handler in-process instead of making a real network request.
+			// This avoids issues on serverless platforms (e.g. Vercel Deployment
+			// Protection blocking server-to-server calls) and eliminates the
+			// latency of a redundant network round-trip + cold start.
+			if (internal_handler !== null) {
+				const resolved_url =
+					typeof input === 'string' ? input : input instanceof Request ? input.url : input.href;
+
+				try {
+					const resolved_origin = new URL(resolved_url).origin;
+					if (resolved_origin === context.origin) {
+						const request = input instanceof Request ? input : new Request(input, init);
+						return internal_handler(request);
+					}
+				} catch {
+					// Not a valid URL — fall through to real fetch
+				}
+			}
 		}
 
 		return original_fetch(input, init);
@@ -107,8 +130,20 @@ export function patch_global_fetch(async_context) {
 
 	globalThis.fetch = /** @type {typeof globalThis.fetch} */ (patched_fetch);
 
-	return () => {
-		globalThis.fetch = original_fetch;
+	return {
+		/** Restore the original fetch. */
+		restore() {
+			globalThis.fetch = original_fetch;
+		},
+		/**
+		 * Set the handler used for same-origin short-circuit.
+		 * Called by createHandler() after the handler function is created.
+		 *
+		 * @param {(request: Request) => Promise<Response>} handler
+		 */
+		set_handler(handler) {
+			internal_handler = handler;
+		},
 	};
 }
 

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "noEmit": true
+  },
+  "include": ["./src/**/*", "./tests/**/*"],
+  "exclude": ["dist", "node_modules"]
+}

package/types/rpc.d.ts

@@ -64,11 +64,30 @@ export type HandleRpcOptions = {
  */
 export function derive_origin(request: Request, trust_proxy: boolean): string;
 
+/**
+ * Return value of patch_global_fetch with methods to control the patched fetch.
+ */
+export type PatchedFetchHandle = {
+	/** Restore the original fetch. */
+	restore: () => void;
+	/**
+	 * Set the handler used for same-origin short-circuit.
+	 * When set, same-origin requests are routed directly through the handler
+	 * in-process instead of making a real network request.
+	 */
+	set_handler: (handler: (request: Request) => Promise<Response>) => void;
+};
+
 /**
  * Patch globalThis.fetch to resolve relative URLs using the async context.
- * Returns a cleanup function that restores the original fetch.
+ * Returns a handle with `restore()` and `set_handler()` methods.
+ *
+ * When `set_handler()` is called with a request handler, same-origin fetch
+ * calls (matching the async context's origin) are routed directly through
+ * the handler in-process, avoiding network round-trips and issues with
+ * serverless platforms (e.g. Vercel Deployment Protection).
  */
-export function patch_global_fetch(async_context: AsyncContext): () => void;
+export function patch_global_fetch(async_context: AsyncContext): PatchedFetchHandle;
 
 /**
  * Build a hash → RpcEntry lookup from rpcModules.