@trpc/openapi 11.19.0-alpha → 11.21.1-canary.20.10e2ef98f

package/dist/index.mjs

@@ -453,16 +453,46 @@ function convertUnionType(type, ctx, depth) {
 	const schemas = effective.map((m) => typeToJsonSchema(m, ctx, depth + 1)).filter(isNonEmptySchema);
 	if (hasBoolPair) schemas.push({ type: "boolean" });
 	if (hasNull) schemas.push({ type: "null" });
-	if (schemas.length === 0) return {};
-	const [firstSchema] = schemas;
-	if (schemas.length === 1 && firstSchema !== void 0) return firstSchema;
-	if (schemas.every(isSimpleTypeSchema)) return { type: schemas.map((s) => s.type) };
-	const discriminatorProp = detectDiscriminatorProperty(schemas);
+	const distinctSchemas = dedupeSchemas(schemas, ctx.schemas);
+	if (distinctSchemas.length === 0) return {};
+	const [firstSchema] = distinctSchemas;
+	if (distinctSchemas.length === 1 && firstSchema !== void 0) return firstSchema;
+	if (distinctSchemas.every(isSimpleTypeSchema)) return { type: distinctSchemas.map((s) => s.type) };
+	const discriminatorProp = detectDiscriminatorProperty(distinctSchemas);
 	if (discriminatorProp) return {
-		oneOf: schemas,
+		oneOf: distinctSchemas,
 		discriminator: { propertyName: discriminatorProp }
 	};
-	return { oneOf: schemas };
+	return { oneOf: distinctSchemas };
+}
+function dedupeSchemas(schemas, components) {
+	const seen = /* @__PURE__ */ new Set();
+	return schemas.filter((schema) => {
+		const key = canonicalize(resolveBareRef(schema, components));
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+/**
+* A `$ref` on its own describes exactly the component it points at, so compare
+* through the component - otherwise the same shape reached both by reference
+* and inline looks like two distinct schemas.
+*/
+function resolveBareRef(schema, components) {
+	if (!isBareRef(schema)) return schema;
+	const target = getReferencedSchema(schema, components);
+	return target && isNonEmptySchema(target) ? target : schema;
+}
+/** A `$ref` with no sibling keys, i.e. one that stands for its component. */
+function isBareRef(schema) {
+	return schema.$ref !== void 0 && Object.keys(schema).length === 1;
+}
+function canonicalize(value) {
+	var _JSON$stringify;
+	if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalize(v)}`).join(",")}}`;
+	return (_JSON$stringify = JSON.stringify(value)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : "undefined";
 }
 /**
 * If every schema in a oneOf is an object with a common required property
@@ -675,7 +705,11 @@ function getProcedureInputTypeName(type, path) {
 			if (declarationName && !ANONYMOUS_NAMES.has(declarationName) && !declarationName.startsWith("__")) return declarationName;
 		}
 	}
-	return `${path.split(".").filter(Boolean).map((segment) => segment.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("")).join("") || "Procedure"}Input`;
+	return `${pascalCasePath(path) || "Procedure"}Input`;
+}
+/** `user.getById` → `UserGetById`, for naming components after a procedure. */
+function pascalCasePath(path) {
+	return path.split(".").filter(Boolean).map((segment) => segment.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("")).join("");
 }
 function isUnknownLikeType(type) {
 	return hasFlag(type, ts.TypeFlags.Unknown | ts.TypeFlags.Any);
@@ -758,9 +792,28 @@ function extractProcedure(def, ctx) {
 		type: def.typeName,
 		inputSchema,
 		outputSchema,
+		errorSchema: extractProcedureErrorSchema($typesType, ctx),
 		description: def.description
 	});
 }
+function extractProcedureErrorSchema($typesType, ctx) {
+	const { schemaCtx } = ctx;
+	const errorSym = $typesType.getProperty("errorShape");
+	if (!errorSym) return null;
+	const { checker } = schemaCtx;
+	const errorType = checker.getTypeOfSymbol(errorSym);
+	if (hasFlag(errorType, ts.TypeFlags.Any) || isUnknownLikeType(errorType) || addsNothingToRouterErrorType(errorType, ctx.routerErrorType, checker)) return null;
+	const schema = typeToJsonSchema(errorType, schemaCtx);
+	return isNonEmptySchema(schema) ? schema : null;
+}
+function addsNothingToRouterErrorType(errorType, routerErrorType, checker) {
+	if (!routerErrorType) return false;
+	if (errorType === routerErrorType) return true;
+	const describe = (type) => checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType);
+	const unionMembers = (type) => type.isUnion() ? type.types : [type];
+	const routerMembers = new Set(unionMembers(routerErrorType).map(describe));
+	return unionMembers(errorType).every((member) => routerMembers.has(describe(member)));
+}
 /** Extract the JSDoc comment text from a symbol, if any. */
 function getJsDocComment(sym, checker) {
 	var _sym$declarations2;
@@ -848,7 +901,7 @@ function loadCompilerOptions(startDir) {
 * it to a JSON Schema.  Returns `null` when the path cannot be resolved
 * (e.g. older tRPC versions or missing type info).
 */
-function extractErrorSchema(routerType, checker, schemaCtx) {
+function getRouterErrorType(routerType, checker) {
 	const walk = (type, keys) => {
 		const [head, ...rest] = keys;
 		if (!head) return type;
@@ -862,10 +915,21 @@ function extractErrorSchema(routerType, checker, schemaCtx) {
 		"$types",
 		"errorShape"
 	]);
+	if (!errorShapeType || hasFlag(errorShapeType, ts.TypeFlags.Any)) return null;
+	return errorShapeType;
+}
+function extractErrorSchema(routerType, checker, schemaCtx) {
+	const errorShapeType = getRouterErrorType(routerType, checker);
 	if (!errorShapeType) return null;
-	if (hasFlag(errorShapeType, ts.TypeFlags.Any)) return null;
 	return typeToJsonSchema(errorShapeType, schemaCtx);
 }
+function wrapInErrorEnvelope(errorSchema) {
+	return {
+		type: "object",
+		properties: { error: errorSchema },
+		required: ["error"]
+	};
+}
 /** Fallback error schema when the router type doesn't expose an error shape. */
 const DEFAULT_ERROR_SCHEMA = {
 	type: "object",
@@ -896,7 +960,7 @@ function wrapInSuccessEnvelope(outputSchema) {
 		required: ["result"]
 	};
 }
-function buildProcedureOperation(proc, method) {
+function buildProcedureOperation(proc, method, errorResponseRef) {
 	const [tag = proc.path] = proc.path.split(".");
 	const operation = _objectSpread2(_objectSpread2({ operationId: proc.path }, proc.description ? { description: proc.description } : {}), {}, {
 		tags: [tag],
@@ -905,7 +969,7 @@ function buildProcedureOperation(proc, method) {
 				description: "Successful response",
 				content: { "application/json": { schema: wrapInSuccessEnvelope(proc.outputSchema) } }
 			},
-			default: { $ref: "#/components/responses/Error" }
+			default: { $ref: errorResponseRef }
 		}
 	});
 	if (proc.inputSchema === null) return operation;
@@ -922,19 +986,56 @@ function buildProcedureOperation(proc, method) {
 	};
 	return operation;
 }
+function buildErrorResponse(schema) {
+	return {
+		description: "Error response",
+		content: { "application/json": { schema: wrapInErrorEnvelope(schema) } }
+	};
+}
+function buildErrorResponses(procedures, routerErrorSchema, schemas) {
+	const responses = { Error: buildErrorResponse(routerErrorSchema) };
+	const shapeKey = (schema) => canonicalize(resolveBareRef(schema, schemas));
+	const refByShape = /* @__PURE__ */ new Map([[shapeKey(routerErrorSchema), "#/components/responses/Error"]]);
+	const refByProcedurePath = /* @__PURE__ */ new Map();
+	for (const proc of procedures) {
+		if (!proc.errorSchema) continue;
+		const key = shapeKey(proc.errorSchema);
+		let ref = refByShape.get(key);
+		if (!ref) {
+			const name = `${pascalCasePath(proc.path) || "Procedure"}Error`;
+			const shape = isBareRef(proc.errorSchema) ? proc.errorSchema : registerSchema(`${name}Shape`, proc.errorSchema, schemas);
+			const responseName = ensureUniqueName(name, responses);
+			responses[responseName] = buildErrorResponse(shape);
+			ref = `#/components/responses/${responseName}`;
+			refByShape.set(key, ref);
+		}
+		refByProcedurePath.set(proc.path, ref);
+	}
+	return {
+		responses,
+		refByProcedurePath
+	};
+}
+function registerSchema(name, schema, schemas) {
+	const refName = ensureUniqueName(name, schemas);
+	schemas[refName] = schema;
+	return { $ref: `#/components/schemas/${refName}` };
+}
 function buildOpenAPIDocument(procedures, options, meta = { errorSchema: null }) {
-	var _options$title, _options$version, _options$servers, _meta$errorSchema;
+	var _meta$schemas, _meta$errorSchema, _options$title, _options$version, _options$servers;
 	const paths = {};
-	for (const proc of procedures) {
-		var _paths$opPath;
-		if (!shouldIncludeProcedureInOpenAPI(proc.type)) continue;
+	const included = procedures.filter((proc) => shouldIncludeProcedureInOpenAPI(proc.type));
+	const schemas = (_meta$schemas = meta.schemas) !== null && _meta$schemas !== void 0 ? _meta$schemas : {};
+	const { responses: errorResponses, refByProcedurePath } = buildErrorResponses(included, (_meta$errorSchema = meta.errorSchema) !== null && _meta$errorSchema !== void 0 ? _meta$errorSchema : DEFAULT_ERROR_SCHEMA, schemas);
+	for (const proc of included) {
+		var _paths$opPath, _refByProcedurePath$g;
 		const opPath = `/${proc.path}`;
 		const method = proc.type === "query" ? "get" : "post";
 		const pathItem = (_paths$opPath = paths[opPath]) !== null && _paths$opPath !== void 0 ? _paths$opPath : {};
 		paths[opPath] = pathItem;
-		pathItem[method] = buildProcedureOperation(proc, method);
+		pathItem[method] = buildProcedureOperation(proc, method, (_refByProcedurePath$g = refByProcedurePath.get(proc.path)) !== null && _refByProcedurePath$g !== void 0 ? _refByProcedurePath$g : "#/components/responses/Error");
 	}
-	const hasNamedSchemas = meta.schemas !== void 0 && Object.keys(meta.schemas).length > 0;
+	const hasNamedSchemas = Object.keys(schemas).length > 0;
 	return _objectSpread2(_objectSpread2({
 		openapi: "3.1.1",
 		jsonSchemaDialect: "https://spec.openapis.org/oas/3.1/dialect/base",
@@ -944,14 +1045,7 @@ function buildOpenAPIDocument(procedures, options, meta = { errorSchema: null })
 		}
 	}, ((_options$servers = options.servers) === null || _options$servers === void 0 ? void 0 : _options$servers.length) ? { servers: options.servers } : {}), {}, {
 		paths,
-		components: _objectSpread2(_objectSpread2({}, hasNamedSchemas && meta.schemas ? { schemas: meta.schemas } : {}), {}, { responses: { Error: {
-			description: "Error response",
-			content: { "application/json": { schema: {
-				type: "object",
-				properties: { error: (_meta$errorSchema = meta.errorSchema) !== null && _meta$errorSchema !== void 0 ? _meta$errorSchema : DEFAULT_ERROR_SCHEMA },
-				required: ["error"]
-			} } }
-		} } })
+		components: _objectSpread2(_objectSpread2({}, hasNamedSchemas ? { schemas } : {}), {}, { responses: errorResponses })
 	});
 }
 /**
@@ -995,7 +1089,8 @@ async function generateOpenAPIDocument(routerFilePath, options = {}) {
 		procedures: [],
 		seen: /* @__PURE__ */ new Set(),
 		schemaCtx,
-		runtimeDescriptions
+		runtimeDescriptions,
+		routerErrorType: getRouterErrorType(routerType, checker)
 	};
 	walkType({
 		type: routerType,