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

package/dist/initTRPC-DjEpHmY2.cjs

@@ -0,0 +1,397 @@
+const require_tracked = require('./tracked-Dl9sBZxY.cjs');
+const require_utils = require('./utils-DVO6HZiR.cjs');
+
+//#region src/unstable-core-do-not-import/middleware.ts
+/** @internal */
+const middlewareMarker = "middlewareMarker";
+/**
+* @internal
+*/
+function createMiddlewareFactory() {
+	function createMiddlewareInner(middlewares) {
+		return {
+			_middlewares: middlewares,
+			unstable_pipe(middlewareBuilderOrFn) {
+				const pipedMiddleware = "_middlewares" in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [middlewareBuilderOrFn];
+				return createMiddlewareInner([...middlewares, ...pipedMiddleware]);
+			}
+		};
+	}
+	function createMiddleware(fn) {
+		return createMiddlewareInner([fn]);
+	}
+	return createMiddleware;
+}
+/**
+* Create a standalone middleware
+* @see https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
+* @deprecated use `.concat()` instead
+*/
+const experimental_standaloneMiddleware = () => ({ create: createMiddlewareFactory() });
+/**
+* @internal
+* Please note, `trpc-openapi` uses this function.
+*/
+function createInputMiddleware(parse) {
+	const inputMiddleware = async function inputValidatorMiddleware(opts) {
+		let parsedInput;
+		const rawInput = await opts.getRawInput();
+		try {
+			parsedInput = await parse(rawInput);
+		} catch (cause) {
+			throw new require_tracked.TRPCError({
+				code: "BAD_REQUEST",
+				cause
+			});
+		}
+		const combinedInput = require_utils.isObject(opts.input) && require_utils.isObject(parsedInput) ? {
+			...opts.input,
+			...parsedInput
+		} : parsedInput;
+		return opts.next({ input: combinedInput });
+	};
+	inputMiddleware._type = "input";
+	return inputMiddleware;
+}
+/**
+* @internal
+*/
+function createOutputMiddleware(parse) {
+	const outputMiddleware = async function outputValidatorMiddleware({ next }) {
+		const result = await next();
+		if (!result.ok) return result;
+		try {
+			const data = await parse(result.data);
+			return {
+				...result,
+				data
+			};
+		} catch (cause) {
+			throw new require_tracked.TRPCError({
+				message: "Output validation failed",
+				code: "INTERNAL_SERVER_ERROR",
+				cause
+			});
+		}
+	};
+	outputMiddleware._type = "output";
+	return outputMiddleware;
+}
+
+//#endregion
+//#region src/vendor/standard-schema-v1/error.ts
+/** A schema error with useful information. */
+var StandardSchemaV1Error = class extends Error {
+	/** The schema issues. */
+	issues;
+	/**
+	* Creates a schema error with useful information.
+	*
+	* @param issues The schema issues.
+	*/
+	constructor(issues) {
+		super(issues[0]?.message);
+		this.name = "SchemaError";
+		this.issues = issues;
+	}
+};
+
+//#endregion
+//#region src/unstable-core-do-not-import/parser.ts
+function getParseFn(procedureParser) {
+	const parser = procedureParser;
+	const isStandardSchema = "~standard" in parser;
+	if (typeof parser === "function" && typeof parser.assert === "function") return parser.assert.bind(parser);
+	if (typeof parser === "function" && !isStandardSchema) return parser;
+	if (typeof parser.parseAsync === "function") return parser.parseAsync.bind(parser);
+	if (typeof parser.parse === "function") return parser.parse.bind(parser);
+	if (typeof parser.validateSync === "function") return parser.validateSync.bind(parser);
+	if (typeof parser.create === "function") return parser.create.bind(parser);
+	if (typeof parser.assert === "function") return (value) => {
+		parser.assert(value);
+		return value;
+	};
+	if (isStandardSchema) return async (value) => {
+		const result = await parser["~standard"].validate(value);
+		if (result.issues) throw new StandardSchemaV1Error(result.issues);
+		return result.value;
+	};
+	throw new Error("Could not find a validator fn");
+}
+
+//#endregion
+//#region src/unstable-core-do-not-import/procedureBuilder.ts
+function createNewBuilder(def1, def2) {
+	const { middlewares = [], inputs, meta,...rest } = def2;
+	return createBuilder({
+		...require_utils.mergeWithoutOverrides(def1, rest),
+		inputs: [...def1.inputs, ...inputs ?? []],
+		middlewares: [...def1.middlewares, ...middlewares],
+		meta: def1.meta && meta ? {
+			...def1.meta,
+			...meta
+		} : meta ?? def1.meta
+	});
+}
+function createBuilder(initDef = {}) {
+	const _def = {
+		procedure: true,
+		inputs: [],
+		middlewares: [],
+		...initDef
+	};
+	const builder = {
+		_def,
+		input(input) {
+			const parser = getParseFn(input);
+			return createNewBuilder(_def, {
+				inputs: [input],
+				middlewares: [createInputMiddleware(parser)]
+			});
+		},
+		output(output) {
+			const parser = getParseFn(output);
+			return createNewBuilder(_def, {
+				output,
+				middlewares: [createOutputMiddleware(parser)]
+			});
+		},
+		meta(meta) {
+			return createNewBuilder(_def, { meta });
+		},
+		use(middlewareBuilderOrFn) {
+			const middlewares = "_middlewares" in middlewareBuilderOrFn ? middlewareBuilderOrFn._middlewares : [middlewareBuilderOrFn];
+			return createNewBuilder(_def, { middlewares });
+		},
+		unstable_concat(builder$1) {
+			return createNewBuilder(_def, builder$1._def);
+		},
+		concat(builder$1) {
+			return createNewBuilder(_def, builder$1._def);
+		},
+		query(resolver) {
+			return createResolver({
+				..._def,
+				type: "query"
+			}, resolver);
+		},
+		mutation(resolver) {
+			return createResolver({
+				..._def,
+				type: "mutation"
+			}, resolver);
+		},
+		subscription(resolver) {
+			return createResolver({
+				..._def,
+				type: "subscription"
+			}, resolver);
+		},
+		experimental_caller(caller) {
+			return createNewBuilder(_def, { caller });
+		}
+	};
+	return builder;
+}
+function createResolver(_defIn, resolver) {
+	const finalBuilder = createNewBuilder(_defIn, {
+		resolver,
+		middlewares: [async function resolveMiddleware(opts) {
+			const data = await resolver(opts);
+			return {
+				marker: middlewareMarker,
+				ok: true,
+				data,
+				ctx: opts.ctx
+			};
+		}]
+	});
+	const _def = {
+		...finalBuilder._def,
+		type: _defIn.type,
+		experimental_caller: Boolean(finalBuilder._def.caller),
+		meta: finalBuilder._def.meta,
+		$types: null
+	};
+	const invoke = createProcedureCaller(finalBuilder._def);
+	const callerOverride = finalBuilder._def.caller;
+	if (!callerOverride) return invoke;
+	const callerWrapper = async (...args) => {
+		return await callerOverride({
+			args,
+			invoke,
+			_def
+		});
+	};
+	callerWrapper._def = _def;
+	return callerWrapper;
+}
+const codeblock = `
+This is a client-only function.
+If you want to call this function on the server, see https://trpc.io/docs/v11/server/server-side-calls
+`.trim();
+async function callRecursive(index, _def, opts) {
+	try {
+		const middleware = _def.middlewares[index];
+		const result = await middleware({
+			...opts,
+			meta: _def.meta,
+			input: opts.input,
+			next(_nextOpts) {
+				const nextOpts = _nextOpts;
+				return callRecursive(index + 1, _def, {
+					...opts,
+					ctx: nextOpts?.ctx ? {
+						...opts.ctx,
+						...nextOpts.ctx
+					} : opts.ctx,
+					input: nextOpts && "input" in nextOpts ? nextOpts.input : opts.input,
+					getRawInput: nextOpts?.getRawInput ?? opts.getRawInput
+				});
+			}
+		});
+		return result;
+	} catch (cause) {
+		return {
+			ok: false,
+			error: require_tracked.getTRPCErrorFromUnknown(cause),
+			marker: middlewareMarker
+		};
+	}
+}
+function createProcedureCaller(_def) {
+	async function procedure(opts) {
+		if (!opts || !("getRawInput" in opts)) throw new Error(codeblock);
+		const result = await callRecursive(0, _def, opts);
+		if (!result) throw new require_tracked.TRPCError({
+			code: "INTERNAL_SERVER_ERROR",
+			message: "No result from middlewares - did you forget to `return next()`?"
+		});
+		if (!result.ok) throw result.error;
+		return result.data;
+	}
+	procedure._def = _def;
+	procedure.procedure = true;
+	procedure.meta = _def.meta;
+	return procedure;
+}
+
+//#endregion
+//#region src/unstable-core-do-not-import/rootConfig.ts
+/**
+* The default check to see if we're in a server
+*/
+const isServerDefault = typeof window === "undefined" || "Deno" in window || globalThis.process?.env?.["NODE_ENV"] === "test" || !!globalThis.process?.env?.["JEST_WORKER_ID"] || !!globalThis.process?.env?.["VITEST_WORKER_ID"];
+
+//#endregion
+//#region src/unstable-core-do-not-import/initTRPC.ts
+var TRPCBuilder = class TRPCBuilder {
+	/**
+	* Add a context shape as a generic to the root object
+	* @see https://trpc.io/docs/v11/server/context
+	*/
+	context() {
+		return new TRPCBuilder();
+	}
+	/**
+	* Add a meta shape as a generic to the root object
+	* @see https://trpc.io/docs/v11/quickstart
+	*/
+	meta() {
+		return new TRPCBuilder();
+	}
+	/**
+	* Create the root object
+	* @see https://trpc.io/docs/v11/server/routers#initialize-trpc
+	*/
+	create(opts) {
+		const config = {
+			...opts,
+			transformer: require_tracked.getDataTransformer(opts?.transformer ?? require_tracked.defaultTransformer),
+			isDev: opts?.isDev ?? globalThis.process?.env["NODE_ENV"] !== "production",
+			allowOutsideOfServer: opts?.allowOutsideOfServer ?? false,
+			errorFormatter: opts?.errorFormatter ?? require_tracked.defaultFormatter,
+			isServer: opts?.isServer ?? isServerDefault,
+			$types: null
+		};
+		{
+			const isServer = opts?.isServer ?? isServerDefault;
+			if (!isServer && opts?.allowOutsideOfServer !== true) throw new Error(`You're trying to use @trpc/server in a non-server environment. This is not supported by default.`);
+		}
+		return {
+			_config: config,
+			procedure: createBuilder({ meta: opts?.defaultMeta }),
+			middleware: createMiddlewareFactory(),
+			router: require_tracked.createRouterFactory(config),
+			mergeRouters: require_tracked.mergeRouters,
+			createCallerFactory: require_tracked.createCallerFactory()
+		};
+	}
+};
+/**
+* Builder to initialize the tRPC root object - use this exactly once per backend
+* @see https://trpc.io/docs/v11/quickstart
+*/
+const initTRPC = new TRPCBuilder();
+
+//#endregion
+Object.defineProperty(exports, 'StandardSchemaV1Error', {
+  enumerable: true,
+  get: function () {
+    return StandardSchemaV1Error;
+  }
+});
+Object.defineProperty(exports, 'createBuilder', {
+  enumerable: true,
+  get: function () {
+    return createBuilder;
+  }
+});
+Object.defineProperty(exports, 'createInputMiddleware', {
+  enumerable: true,
+  get: function () {
+    return createInputMiddleware;
+  }
+});
+Object.defineProperty(exports, 'createMiddlewareFactory', {
+  enumerable: true,
+  get: function () {
+    return createMiddlewareFactory;
+  }
+});
+Object.defineProperty(exports, 'createOutputMiddleware', {
+  enumerable: true,
+  get: function () {
+    return createOutputMiddleware;
+  }
+});
+Object.defineProperty(exports, 'experimental_standaloneMiddleware', {
+  enumerable: true,
+  get: function () {
+    return experimental_standaloneMiddleware;
+  }
+});
+Object.defineProperty(exports, 'getParseFn', {
+  enumerable: true,
+  get: function () {
+    return getParseFn;
+  }
+});
+Object.defineProperty(exports, 'initTRPC', {
+  enumerable: true,
+  get: function () {
+    return initTRPC;
+  }
+});
+Object.defineProperty(exports, 'isServerDefault', {
+  enumerable: true,
+  get: function () {
+    return isServerDefault;
+  }
+});
+Object.defineProperty(exports, 'middlewareMarker', {
+  enumerable: true,
+  get: function () {
+    return middlewareMarker;
+  }
+});

package/dist/node-http-BPR68yI4.cjs

@@ -0,0 +1,243 @@
+const require_resolveResponse = require('./resolveResponse-B2CuaT_1.cjs');
+const require_getErrorShape = require('./getErrorShape-CsikfkAc.cjs');
+const require_tracked = require('./tracked-Dl9sBZxY.cjs');
+const require_utils = require('./utils-DVO6HZiR.cjs');
+
+//#region src/adapters/node-http/incomingMessageToRequest.ts
+function createBody(req, opts) {
+	if ("body" in req) {
+		if (req.body === void 0) return void 0;
+		if (typeof req.body === "string") return req.body;
+		return JSON.stringify(req.body);
+	}
+	let size = 0;
+	let hasClosed = false;
+	return new ReadableStream({
+		start(controller) {
+			const onData = (chunk) => {
+				size += chunk.length;
+				if (!opts.maxBodySize || size <= opts.maxBodySize) {
+					controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+					return;
+				}
+				controller.error(new require_tracked.TRPCError({ code: "PAYLOAD_TOO_LARGE" }));
+				hasClosed = true;
+				req.off("data", onData);
+				req.off("end", onEnd);
+			};
+			const onEnd = () => {
+				if (hasClosed) return;
+				hasClosed = true;
+				req.off("data", onData);
+				req.off("end", onEnd);
+				controller.close();
+			};
+			req.on("data", onData);
+			req.on("end", onEnd);
+		},
+		cancel() {
+			req.destroy();
+		}
+	});
+}
+function createURL(req) {
+	try {
+		const protocol = req.headers[":scheme"] && req.headers[":scheme"] === "https" || req.socket && "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
+		const host = req.headers.host ?? req.headers[":authority"] ?? "localhost";
+		return new URL(req.url, `${protocol}//${host}`);
+	} catch (cause) {
+		throw new require_tracked.TRPCError({
+			code: "BAD_REQUEST",
+			message: "Invalid URL",
+			cause
+		});
+	}
+}
+function createHeaders(incoming) {
+	const headers = new Headers();
+	for (const key in incoming) {
+		const value = incoming[key];
+		if (typeof key === "string" && key.startsWith(":")) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(key, item);
+		else if (value != null) headers.append(key, value);
+	}
+	return headers;
+}
+/**
+* Convert an [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage) to a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+*/
+function incomingMessageToRequest(req, res, opts) {
+	const ac = new AbortController();
+	const onAbort = () => {
+		res.off("close", onAbort);
+		req.socket?.off?.("close", onAbort);
+		ac.abort();
+	};
+	res.once("close", onAbort);
+	req.socket?.once?.("close", onAbort);
+	const url = createURL(req);
+	const init = {
+		headers: createHeaders(req.headers),
+		method: req.method,
+		signal: ac.signal
+	};
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		init.body = createBody(req, opts);
+		init.duplex = "half";
+	}
+	const request = new Request(url, init);
+	return request;
+}
+
+//#endregion
+//#region src/adapters/node-http/writeResponse.ts
+async function writeResponseBodyChunk(res, chunk) {
+	if (res.write(chunk) === false) await new Promise((resolve, reject) => {
+		const onError = (err) => {
+			reject(err);
+			cleanup();
+		};
+		const onDrain = () => {
+			resolve();
+			cleanup();
+		};
+		const cleanup = () => {
+			res.off("error", onError);
+			res.off("drain", onDrain);
+		};
+		res.once("error", onError);
+		res.once("drain", onDrain);
+	});
+}
+/**
+* @internal
+*/
+async function writeResponseBody(opts) {
+	const { res } = opts;
+	try {
+		const writableStream = new WritableStream({ async write(chunk) {
+			await writeResponseBodyChunk(res, chunk);
+			res.flush?.();
+		} });
+		await opts.body.pipeTo(writableStream, { signal: opts.signal });
+	} catch (err) {
+		if (require_resolveResponse.isAbortError(err)) return;
+		throw err;
+	}
+}
+/**
+* @internal
+*/
+async function writeResponse(opts) {
+	const { response, rawResponse } = opts;
+	if (rawResponse.statusCode === 200) rawResponse.statusCode = response.status;
+	for (const [key, value] of response.headers) rawResponse.setHeader(key, value);
+	try {
+		if (response.body) await writeResponseBody({
+			res: rawResponse,
+			signal: opts.request.signal,
+			body: response.body
+		});
+	} catch (err) {
+		if (!rawResponse.headersSent) rawResponse.statusCode = 500;
+		throw err;
+	} finally {
+		rawResponse.end();
+	}
+}
+
+//#endregion
+//#region src/adapters/node-http/nodeHTTPRequestHandler.ts
+/**
+* @internal
+*/
+function internal_exceptionHandler(opts) {
+	return (cause) => {
+		const { res, req } = opts;
+		const error = require_tracked.getTRPCErrorFromUnknown(cause);
+		const shape = require_getErrorShape.getErrorShape({
+			config: opts.router._def._config,
+			error,
+			type: "unknown",
+			path: void 0,
+			input: void 0,
+			ctx: void 0
+		});
+		opts.onError?.({
+			req,
+			error,
+			type: "unknown",
+			path: void 0,
+			input: void 0,
+			ctx: void 0
+		});
+		const transformed = require_tracked.transformTRPCResponse(opts.router._def._config, { error: shape });
+		res.statusCode = shape.data.httpStatus;
+		res.end(JSON.stringify(transformed));
+	};
+}
+/**
+* @remark the promise never rejects
+*/
+async function nodeHTTPRequestHandler(opts) {
+	return new Promise((resolve) => {
+		const handleViaMiddleware = opts.middleware ?? ((_req, _res, next) => next());
+		opts.res.once("finish", () => {
+			resolve();
+		});
+		return handleViaMiddleware(opts.req, opts.res, (err) => {
+			require_utils.run(async () => {
+				const request = incomingMessageToRequest(opts.req, opts.res, { maxBodySize: opts.maxBodySize ?? null });
+				const createContext = async (innerOpts) => {
+					return await opts.createContext?.({
+						...opts,
+						...innerOpts
+					});
+				};
+				const response = await require_resolveResponse.resolveResponse({
+					...opts,
+					req: request,
+					error: err ? require_tracked.getTRPCErrorFromUnknown(err) : null,
+					createContext,
+					onError(o) {
+						opts?.onError?.({
+							...o,
+							req: opts.req
+						});
+					}
+				});
+				await writeResponse({
+					request,
+					response,
+					rawResponse: opts.res
+				});
+			}).catch(internal_exceptionHandler(opts));
+		});
+	});
+}
+
+//#endregion
+Object.defineProperty(exports, 'createURL', {
+  enumerable: true,
+  get: function () {
+    return createURL;
+  }
+});
+Object.defineProperty(exports, 'incomingMessageToRequest', {
+  enumerable: true,
+  get: function () {
+    return incomingMessageToRequest;
+  }
+});
+Object.defineProperty(exports, 'internal_exceptionHandler', {
+  enumerable: true,
+  get: function () {
+    return internal_exceptionHandler;
+  }
+});
+Object.defineProperty(exports, 'nodeHTTPRequestHandler', {
+  enumerable: true,
+  get: function () {
+    return nodeHTTPRequestHandler;
+  }
+});