@trpc/server 11.1.3-alpha-tmp-tsdown.23 → 11.1.3-alpha-tmp-tsdown.26

package/dist/adapters/ws.mjs

@@ -1,416 +1,15 @@
-import { __toESM } from "../_virtual/rolldown_runtime.mjs";
-import { isAsyncIterable, isObject, run } from "../unstable-core-do-not-import/utils.mjs";
-import { parseTRPCMessage } from "../unstable-core-do-not-import/rpc/parseTRPCMessage.mjs";
-import { getErrorShape } from "../unstable-core-do-not-import/error/getErrorShape.mjs";
-import { TRPCError, getTRPCErrorFromUnknown } from "../unstable-core-do-not-import/error/TRPCError.mjs";
-import { transformTRPCResponse } from "../unstable-core-do-not-import/transformer.mjs";
-import { callProcedure } from "../unstable-core-do-not-import/router.mjs";
-import { parseConnectionParamsFromUnknown } from "../unstable-core-do-not-import/http/parseConnectionParams.mjs";
-import { isObservable, observableToAsyncIterable } from "../observable/observable.mjs";
-import { Unpromise } from "../vendor/unpromise/unpromise.mjs";
-import { require_usingCtx } from "../node_modules/.pnpm/@oxc-project_runtime@0.71.0/node_modules/@oxc-project/runtime/src/helpers/usingCtx.mjs";
-import { iteratorResource } from "../unstable-core-do-not-import/stream/utils/asyncIterable.mjs";
-import { isTrackedEnvelope } from "../unstable-core-do-not-import/stream/tracked.mjs";
-import { createURL } from "./node-http/incomingMessageToRequest.mjs";
+import "../resolveResponse-DPbYgJDD.mjs";
+import "../getErrorShape-DyYil4aT.mjs";
+import "../tracked-GEWPoL0C.mjs";
+import "../utils-BHZJcBRv.mjs";
+import "../parseTRPCMessage-CNyYMSRB.mjs";
+import "../contentTypeParsers-SN4WL9ze.mjs";
+import "../unstable-core-do-not-import-D89CaGtL.mjs";
+import "../observable-B1orLHHI.mjs";
+import "../initTRPC-COaJMShh.mjs";
+import "../http-CWyjOa1l.mjs";
+import "../node-http-BUQnHuGI.mjs";
+import "../observable-CFXA_tyK.mjs";
+import { applyWSSHandler, getWSConnectionHandler, handleKeepAlive } from "../ws-eIVIMTrw.mjs";
 
-//#region src/adapters/ws.ts
-var import_usingCtx = __toESM(require_usingCtx());
-/**
-* Importing ws causes a build error
-* @see https://github.com/trpc/trpc/pull/5279
-*/
-const WEBSOCKET_OPEN = 1;
-function getWSConnectionHandler(opts) {
-	const { createContext, router } = opts;
-	const { transformer } = router._def._config;
-	return (client, req) => {
-		const clientSubscriptions = new Map();
-		const abortController = new AbortController();
-		if (opts.keepAlive?.enabled) {
-			const { pingMs, pongWaitMs } = opts.keepAlive;
-			handleKeepAlive(client, pingMs, pongWaitMs);
-		}
-		function respond(untransformedJSON) {
-			client.send(JSON.stringify(transformTRPCResponse(router._def._config, untransformedJSON)));
-		}
-		async function createCtxPromise(getConnectionParams) {
-			try {
-				return await run(async () => {
-					ctx = await createContext?.({
-						req,
-						res: client,
-						info: {
-							connectionParams: getConnectionParams(),
-							calls: [],
-							isBatchCall: false,
-							accept: null,
-							type: "unknown",
-							signal: abortController.signal,
-							url: null
-						}
-					});
-					return {
-						ok: true,
-						value: ctx
-					};
-				});
-			} catch (cause) {
-				const error = getTRPCErrorFromUnknown(cause);
-				opts.onError?.({
-					error,
-					path: void 0,
-					type: "unknown",
-					ctx,
-					req,
-					input: void 0
-				});
-				respond({
-					id: null,
-					error: getErrorShape({
-						config: router._def._config,
-						error,
-						type: "unknown",
-						path: void 0,
-						input: void 0,
-						ctx
-					})
-				});
-				(globalThis.setImmediate ?? globalThis.setTimeout)(() => {
-					client.close();
-				});
-				return {
-					ok: false,
-					error
-				};
-			}
-		}
-		let ctx = void 0;
-		/**
-		* promise for initializing the context
-		*
-		* - the context promise will be created immediately on connection if no connectionParams are expected
-		* - if connection params are expected, they will be created once received
-		*/
-		let ctxPromise = createURL(req).searchParams.get("connectionParams") === "1" ? null : createCtxPromise(() => null);
-		function handleRequest(msg) {
-			const { id, jsonrpc } = msg;
-			if (id === null) {
-				const error = getTRPCErrorFromUnknown(new TRPCError({
-					code: "PARSE_ERROR",
-					message: "`id` is required"
-				}));
-				opts.onError?.({
-					error,
-					path: void 0,
-					type: "unknown",
-					ctx,
-					req,
-					input: void 0
-				});
-				respond({
-					id,
-					jsonrpc,
-					error: getErrorShape({
-						config: router._def._config,
-						error,
-						type: "unknown",
-						path: void 0,
-						input: void 0,
-						ctx
-					})
-				});
-				return;
-			}
-			if (msg.method === "subscription.stop") {
-				clientSubscriptions.get(id)?.abort();
-				return;
-			}
-			const { path, lastEventId } = msg.params;
-			let { input } = msg.params;
-			const type = msg.method;
-			if (lastEventId !== void 0) if (isObject(input)) input = {
-				...input,
-				lastEventId
-			};
-			else input ??= { lastEventId };
-			run(async () => {
-				const res = await ctxPromise;
-				if (!res.ok) throw res.error;
-				const abortController$1 = new AbortController();
-				const result = await callProcedure({
-					router,
-					path,
-					getRawInput: async () => input,
-					ctx,
-					type,
-					signal: abortController$1.signal
-				});
-				const isIterableResult = isAsyncIterable(result) || isObservable(result);
-				if (type !== "subscription") {
-					if (isIterableResult) throw new TRPCError({
-						code: "UNSUPPORTED_MEDIA_TYPE",
-						message: `Cannot return an async iterable or observable from a ${type} procedure with WebSockets`
-					});
-					respond({
-						id,
-						jsonrpc,
-						result: {
-							type: "data",
-							data: result
-						}
-					});
-					return;
-				}
-				if (!isIterableResult) throw new TRPCError({
-					message: `Subscription ${path} did not return an observable or a AsyncGenerator`,
-					code: "INTERNAL_SERVER_ERROR"
-				});
-				/* istanbul ignore next -- @preserve */
-				if (client.readyState !== WEBSOCKET_OPEN) return;
-				/* istanbul ignore next -- @preserve */
-				if (clientSubscriptions.has(id)) throw new TRPCError({
-					message: `Duplicate id ${id}`,
-					code: "BAD_REQUEST"
-				});
-				const iterable = isObservable(result) ? observableToAsyncIterable(result, abortController$1.signal) : result;
-				run(async () => {
-					try {
-						var _usingCtx = (0, import_usingCtx.default)();
-						const iterator = _usingCtx.a(iteratorResource(iterable));
-						const abortPromise = new Promise((resolve) => {
-							abortController$1.signal.onabort = () => resolve("abort");
-						});
-						let next;
-						let result$1;
-						while (true) {
-							next = await Unpromise.race([iterator.next().catch(getTRPCErrorFromUnknown), abortPromise]);
-							if (next === "abort") {
-								await iterator.return?.();
-								break;
-							}
-							if (next instanceof Error) {
-								const error = getTRPCErrorFromUnknown(next);
-								opts.onError?.({
-									error,
-									path,
-									type,
-									ctx,
-									req,
-									input
-								});
-								respond({
-									id,
-									jsonrpc,
-									error: getErrorShape({
-										config: router._def._config,
-										error,
-										type,
-										path,
-										input,
-										ctx
-									})
-								});
-								break;
-							}
-							if (next.done) break;
-							result$1 = {
-								type: "data",
-								data: next.value
-							};
-							if (isTrackedEnvelope(next.value)) {
-								const [id$1, data] = next.value;
-								result$1.id = id$1;
-								result$1.data = {
-									id: id$1,
-									data
-								};
-							}
-							respond({
-								id,
-								jsonrpc,
-								result: result$1
-							});
-							next = null;
-							result$1 = null;
-						}
-						respond({
-							id,
-							jsonrpc,
-							result: { type: "stopped" }
-						});
-						clientSubscriptions.delete(id);
-					} catch (_) {
-						_usingCtx.e = _;
-					} finally {
-						await _usingCtx.d();
-					}
-				}).catch((cause) => {
-					const error = getTRPCErrorFromUnknown(cause);
-					opts.onError?.({
-						error,
-						path,
-						type,
-						ctx,
-						req,
-						input
-					});
-					respond({
-						id,
-						jsonrpc,
-						error: getErrorShape({
-							config: router._def._config,
-							error,
-							type,
-							path,
-							input,
-							ctx
-						})
-					});
-					abortController$1.abort();
-				});
-				clientSubscriptions.set(id, abortController$1);
-				respond({
-					id,
-					jsonrpc,
-					result: { type: "started" }
-				});
-			}).catch((cause) => {
-				const error = getTRPCErrorFromUnknown(cause);
-				opts.onError?.({
-					error,
-					path,
-					type,
-					ctx,
-					req,
-					input
-				});
-				respond({
-					id,
-					jsonrpc,
-					error: getErrorShape({
-						config: router._def._config,
-						error,
-						type,
-						path,
-						input,
-						ctx
-					})
-				});
-			});
-		}
-		client.on("message", (rawData) => {
-			const msgStr = rawData.toString();
-			if (msgStr === "PONG") return;
-			if (msgStr === "PING") {
-				if (!opts.dangerouslyDisablePong) client.send("PONG");
-				return;
-			}
-			if (!ctxPromise) {
-				ctxPromise = createCtxPromise(() => {
-					let msg;
-					try {
-						msg = JSON.parse(msgStr);
-						if (!isObject(msg)) throw new Error("Message was not an object");
-					} catch (cause) {
-						throw new TRPCError({
-							code: "PARSE_ERROR",
-							message: `Malformed TRPCConnectionParamsMessage`,
-							cause
-						});
-					}
-					const connectionParams = parseConnectionParamsFromUnknown(msg.data);
-					return connectionParams;
-				});
-				return;
-			}
-			const parsedMsgs = run(() => {
-				try {
-					const msgJSON = JSON.parse(msgStr);
-					const msgs = Array.isArray(msgJSON) ? msgJSON : [msgJSON];
-					return msgs.map((raw) => parseTRPCMessage(raw, transformer));
-				} catch (cause) {
-					const error = new TRPCError({
-						code: "PARSE_ERROR",
-						cause
-					});
-					respond({
-						id: null,
-						error: getErrorShape({
-							config: router._def._config,
-							error,
-							type: "unknown",
-							path: void 0,
-							input: void 0,
-							ctx
-						})
-					});
-					return [];
-				}
-			});
-			parsedMsgs.map(handleRequest);
-		});
-		client.on("error", (cause) => {
-			opts.onError?.({
-				ctx,
-				error: getTRPCErrorFromUnknown(cause),
-				input: void 0,
-				path: void 0,
-				type: "unknown",
-				req
-			});
-		});
-		client.once("close", () => {
-			for (const sub of clientSubscriptions.values()) sub.abort();
-			clientSubscriptions.clear();
-			abortController.abort();
-		});
-	};
-}
-/**
-* Handle WebSocket keep-alive messages
-*/
-function handleKeepAlive(client, pingMs = 3e4, pongWaitMs = 5e3) {
-	let timeout = void 0;
-	let ping = void 0;
-	const schedulePing = () => {
-		const scheduleTimeout = () => {
-			timeout = setTimeout(() => {
-				client.terminate();
-			}, pongWaitMs);
-		};
-		ping = setTimeout(() => {
-			client.send("PING");
-			scheduleTimeout();
-		}, pingMs);
-	};
-	const onMessage = () => {
-		clearTimeout(ping);
-		clearTimeout(timeout);
-		schedulePing();
-	};
-	client.on("message", onMessage);
-	client.on("close", () => {
-		clearTimeout(ping);
-		clearTimeout(timeout);
-	});
-	schedulePing();
-}
-function applyWSSHandler(opts) {
-	const onConnection = getWSConnectionHandler(opts);
-	opts.wss.on("connection", (client, req) => {
-		if (opts.prefix && !req.url?.startsWith(opts.prefix)) return;
-		onConnection(client, req);
-	});
-	return { broadcastReconnectNotification: () => {
-		const response = {
-			id: null,
-			method: "reconnect"
-		};
-		const data = JSON.stringify(response);
-		for (const client of opts.wss.clients) if (client.readyState === WEBSOCKET_OPEN) client.send(data);
-	} };
-}
-
-//#endregion
-export { applyWSSHandler, getWSConnectionHandler, handleKeepAlive };
-//# sourceMappingURL=ws.mjs.map
+export { applyWSSHandler, getWSConnectionHandler, handleKeepAlive };

package/dist/{unstable-core-do-not-import/http/contentTypeParsers.mjs → contentTypeParsers-SN4WL9ze.mjs}

@@ -10,4 +10,4 @@ const octetInputParser = {
 
 //#endregion
 export { octetInputParser };
-//# sourceMappingURL=contentTypeParsers.mjs.map
+//# sourceMappingURL=contentTypeParsers-SN4WL9ze.mjs.map

package/dist/contentTypeParsers-SN4WL9ze.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentTypeParsers-SN4WL9ze.mjs","names":["octetInputParser: UtilityParser<OctetInput, ReadableStream>"],"sources":["../src/unstable-core-do-not-import/http/contentTypeParsers.ts"],"sourcesContent":["import type { ParserZodEsque } from '../parser';\n\ntype UtilityParser<TInput, TOutput> = ParserZodEsque<TInput, TOutput> & {\n  parse: (input: unknown) => TOutput;\n};\n\n// Should be the same possible types as packages/client/src/links/internals/contentTypes.ts isOctetType\n\n/**\n * File is only available from Node19+ but it always extends Blob so we can use that as a type until we eventually drop Node18\n */\ninterface FileLike extends Blob {\n  readonly name: string;\n}\n\ntype OctetInput = Blob | Uint8Array | FileLike;\nexport const octetInputParser: UtilityParser<OctetInput, ReadableStream> = {\n  _input: null as any as OctetInput,\n  _output: null as any as ReadableStream,\n  parse(input) {\n    if (input instanceof ReadableStream) {\n      return input;\n    }\n\n    throw new Error(\n      `Parsed input was expected to be a ReadableStream but was: ${typeof input}`,\n    );\n  },\n};\n"],"mappings":";AAgBA,MAAaA,mBAA8D;CACzE,QAAQ;CACR,SAAS;CACT,MAAM,OAAO;AACX,MAAI,iBAAiB,eACnB,QAAO;AAGT,QAAM,IAAI,OACP,mEAAmE,MAAM;CAE7E;AACF"}

package/dist/{unstable-core-do-not-import/http/contentTypeParsers.js → contentTypeParsers-iAFF_pJG.cjs}

@@ -10,4 +10,9 @@ const octetInputParser = {
 };
 
 //#endregion
-exports.octetInputParser = octetInputParser;
+Object.defineProperty(exports, 'octetInputParser', {
+  enumerable: true,
+  get: function () {
+    return octetInputParser;
+  }
+});

package/dist/getErrorShape-CsikfkAc.cjs

@@ -0,0 +1,201 @@
+const require_utils = require('./utils-DVO6HZiR.cjs');
+
+//#region src/unstable-core-do-not-import/createProxy.ts
+const noop = () => {};
+const freezeIfAvailable = (obj) => {
+	if (Object.freeze) Object.freeze(obj);
+};
+function createInnerProxy(callback, path, memo) {
+	const cacheKey = path.join(".");
+	memo[cacheKey] ??= new Proxy(noop, {
+		get(_obj, key) {
+			if (typeof key !== "string" || key === "then") return void 0;
+			return createInnerProxy(callback, [...path, key], memo);
+		},
+		apply(_1, _2, args) {
+			const lastOfPath = path[path.length - 1];
+			let opts = {
+				args,
+				path
+			};
+			if (lastOfPath === "call") opts = {
+				args: args.length >= 2 ? [args[1]] : [],
+				path: path.slice(0, -1)
+			};
+			else if (lastOfPath === "apply") opts = {
+				args: args.length >= 2 ? args[1] : [],
+				path: path.slice(0, -1)
+			};
+			freezeIfAvailable(opts.args);
+			freezeIfAvailable(opts.path);
+			return callback(opts);
+		}
+	});
+	return memo[cacheKey];
+}
+/**
+* Creates a proxy that calls the callback with the path and arguments
+*
+* @internal
+*/
+const createRecursiveProxy = (callback) => createInnerProxy(callback, [], Object.create(null));
+/**
+* Used in place of `new Proxy` where each handler will map 1 level deep to another value.
+*
+* @internal
+*/
+const createFlatProxy = (callback) => {
+	return new Proxy(noop, { get(_obj, name) {
+		if (name === "then") return void 0;
+		return callback(name);
+	} });
+};
+
+//#endregion
+//#region src/unstable-core-do-not-import/http/getHTTPStatusCode.ts
+const JSONRPC2_TO_HTTP_CODE = {
+	PARSE_ERROR: 400,
+	BAD_REQUEST: 400,
+	UNAUTHORIZED: 401,
+	PAYMENT_REQUIRED: 402,
+	FORBIDDEN: 403,
+	NOT_FOUND: 404,
+	METHOD_NOT_SUPPORTED: 405,
+	TIMEOUT: 408,
+	CONFLICT: 409,
+	PRECONDITION_FAILED: 412,
+	PAYLOAD_TOO_LARGE: 413,
+	UNSUPPORTED_MEDIA_TYPE: 415,
+	UNPROCESSABLE_CONTENT: 422,
+	TOO_MANY_REQUESTS: 429,
+	CLIENT_CLOSED_REQUEST: 499,
+	INTERNAL_SERVER_ERROR: 500,
+	NOT_IMPLEMENTED: 501,
+	BAD_GATEWAY: 502,
+	SERVICE_UNAVAILABLE: 503,
+	GATEWAY_TIMEOUT: 504
+};
+const HTTP_CODE_TO_JSONRPC2 = {
+	400: "BAD_REQUEST",
+	401: "UNAUTHORIZED",
+	402: "PAYMENT_REQUIRED",
+	403: "FORBIDDEN",
+	404: "NOT_FOUND",
+	405: "METHOD_NOT_SUPPORTED",
+	408: "TIMEOUT",
+	409: "CONFLICT",
+	412: "PRECONDITION_FAILED",
+	413: "PAYLOAD_TOO_LARGE",
+	415: "UNSUPPORTED_MEDIA_TYPE",
+	422: "UNPROCESSABLE_CONTENT",
+	429: "TOO_MANY_REQUESTS",
+	499: "CLIENT_CLOSED_REQUEST",
+	500: "INTERNAL_SERVER_ERROR",
+	501: "NOT_IMPLEMENTED",
+	502: "BAD_GATEWAY",
+	503: "SERVICE_UNAVAILABLE",
+	504: "GATEWAY_TIMEOUT"
+};
+function getStatusCodeFromKey(code) {
+	return JSONRPC2_TO_HTTP_CODE[code] ?? 500;
+}
+function getStatusKeyFromCode(code) {
+	return HTTP_CODE_TO_JSONRPC2[code] ?? "INTERNAL_SERVER_ERROR";
+}
+function getHTTPStatusCode(json) {
+	const arr = Array.isArray(json) ? json : [json];
+	const httpStatuses = new Set(arr.map((res) => {
+		if ("error" in res && require_utils.isObject(res.error.data)) {
+			if (typeof res.error.data?.["httpStatus"] === "number") return res.error.data["httpStatus"];
+			const code = require_utils.TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
+			return getStatusCodeFromKey(code);
+		}
+		return 200;
+	}));
+	if (httpStatuses.size !== 1) return 207;
+	const httpStatus = httpStatuses.values().next().value;
+	return httpStatus;
+}
+function getHTTPStatusCodeFromError(error) {
+	return getStatusCodeFromKey(error.code);
+}
+
+//#endregion
+//#region src/unstable-core-do-not-import/error/getErrorShape.ts
+/**
+* @internal
+*/
+function getErrorShape(opts) {
+	const { path, error, config } = opts;
+	const { code } = opts.error;
+	const shape = {
+		message: error.message,
+		code: require_utils.TRPC_ERROR_CODES_BY_KEY[code],
+		data: {
+			code,
+			httpStatus: getHTTPStatusCodeFromError(error)
+		}
+	};
+	if (config.isDev && typeof opts.error.stack === "string") shape.data.stack = opts.error.stack;
+	if (typeof path === "string") shape.data.path = path;
+	return config.errorFormatter({
+		...opts,
+		shape
+	});
+}
+
+//#endregion
+Object.defineProperty(exports, 'HTTP_CODE_TO_JSONRPC2', {
+  enumerable: true,
+  get: function () {
+    return HTTP_CODE_TO_JSONRPC2;
+  }
+});
+Object.defineProperty(exports, 'JSONRPC2_TO_HTTP_CODE', {
+  enumerable: true,
+  get: function () {
+    return JSONRPC2_TO_HTTP_CODE;
+  }
+});
+Object.defineProperty(exports, 'createFlatProxy', {
+  enumerable: true,
+  get: function () {
+    return createFlatProxy;
+  }
+});
+Object.defineProperty(exports, 'createRecursiveProxy', {
+  enumerable: true,
+  get: function () {
+    return createRecursiveProxy;
+  }
+});
+Object.defineProperty(exports, 'getErrorShape', {
+  enumerable: true,
+  get: function () {
+    return getErrorShape;
+  }
+});
+Object.defineProperty(exports, 'getHTTPStatusCode', {
+  enumerable: true,
+  get: function () {
+    return getHTTPStatusCode;
+  }
+});
+Object.defineProperty(exports, 'getHTTPStatusCodeFromError', {
+  enumerable: true,
+  get: function () {
+    return getHTTPStatusCodeFromError;
+  }
+});
+Object.defineProperty(exports, 'getStatusCodeFromKey', {
+  enumerable: true,
+  get: function () {
+    return getStatusCodeFromKey;
+  }
+});
+Object.defineProperty(exports, 'getStatusKeyFromCode', {
+  enumerable: true,
+  get: function () {
+    return getStatusKeyFromCode;
+  }
+});