@mastra/nestjs 0.2.26 → 0.2.27-alpha.10

package/dist/index.js

@@ -1,6 +1,6 @@
 import { createRequire } from "module";
 import { All, BadRequestException, Catch, Controller, ForbiddenException, Get, HttpException, HttpStatus, Inject, Injectable, Logger, Module, NotFoundException, PayloadTooLargeException, Req, Res, Scope, ServiceUnavailableException, SetMetadata, UnauthorizedException, UseFilters, UseGuards, UseInterceptors } from "@nestjs/common";
-import { MASTRA_CLIENT_TYPE_HEADER, MASTRA_IS_STUDIO_KEY, SERVER_ROUTES, isReservedRequestContextKey, isStudioClientTypeHeader, isZodError, normalizeQueryParams, redactStreamChunk, serializeStreamChunk } from "@mastra/server/server-adapter";
+import { HTTPException, MASTRA_CLIENT_TYPE_HEADER, MASTRA_IS_STUDIO_KEY, SERVER_ROUTES, getCustomHTTPExceptionResponse, isReservedRequestContextKey, isStudioClientTypeHeader, isZodError, normalizeQueryParams, redactStreamChunk, serializeStreamChunk } from "@mastra/server/server-adapter";
 import { formatZodError, isZodError as isZodError$1 } from "@mastra/server/handlers/error";
 import { canAccessPublicly, checkRules, defaultAuthConfig, isDevPlaygroundRequest, isProtectedPath } from "@mastra/server/auth";
 import { RequestContext } from "@mastra/core/request-context";
@@ -64,6 +64,27 @@ function __decorate(decorators, target, key, desc) {
 //#endregion
 //#region src/services/route-handler.service.ts
 var _RouteHandlerService;
+const VALIDATION_CONTEXT_LABELS = {
+	query: "query parameters",
+	body: "request body",
+	path: "path parameters"
+};
+function getSchemaTypeName(schema) {
+	if (!schema || typeof schema !== "object") return;
+	const definition = schema._def ?? schema.def;
+	return definition?.typeName ?? definition?.type;
+}
+function unwrapOptionalNullable(schema) {
+	let inner = schema;
+	let typeName = getSchemaTypeName(inner);
+	while (typeName === "ZodOptional" || typeName === "optional" || typeName === "ZodNullable" || typeName === "nullable") {
+		const definition = inner?._def ?? inner?.def;
+		if (!definition?.innerType) return inner;
+		inner = definition.innerType;
+		typeName = getSchemaTypeName(inner);
+	}
+	return inner;
+}
 let RouteHandlerService = _RouteHandlerService = class RouteHandlerService {
 	mastra;
 	options;
@@ -81,10 +102,14 @@ let RouteHandlerService = _RouteHandlerService = class RouteHandlerService {
 		this.mastra = mastra;
 		this.options = options;
 		this.routeMap = /* @__PURE__ */ new Map();
-		for (const route of SERVER_ROUTES) {
-			const key = this.getRouteKey(route.method, route.path);
-			this.routeMap.set(key, route);
-		}
+		for (const route of SERVER_ROUTES) this.registerRoute(route);
+	}
+	/**
+	* Register a route with the catch-all NestJS controller.
+	*/
+	registerRoute(route) {
+		const key = this.getRouteKey(route.method, route.path);
+		this.routeMap.set(key, route);
 	}
 	/**
 	* Find a route by exact method and path pattern.
@@ -111,7 +136,7 @@ let RouteHandlerService = _RouteHandlerService = class RouteHandlerService {
 				route: exactRoute,
 				pathParams: {}
 			};
-			for (const route of SERVER_ROUTES) {
+			for (const route of this.routeMap.values()) {
 				if (route.method.toUpperCase() !== checkMethod) continue;
 				const pathParams = this.matchPath(route.path, path);
 				if (pathParams) return {
@@ -126,7 +151,7 @@ let RouteHandlerService = _RouteHandlerService = class RouteHandlerService {
 	* Get all routes (for dynamic controller generation).
 	*/
 	getAllRoutes() {
-		return SERVER_ROUTES;
+		return Array.from(this.routeMap.values());
 	}
 	/**
 	* Match a path against a route pattern.
@@ -160,21 +185,21 @@ let RouteHandlerService = _RouteHandlerService = class RouteHandlerService {
 		if (route.pathParamSchema) try {
 			validatedPathParams = await route.pathParamSchema.parseAsync(params.pathParams);
 		} catch (error) {
-			if (isZodError(error)) throw new ValidationError("Invalid path parameters", error);
+			if (isZodError(error)) throw this.createValidationError(route, error, "path");
 			throw error;
 		}
 		let validatedQueryParams = params.queryParams;
 		if (route.queryParamSchema) try {
 			validatedQueryParams = await route.queryParamSchema.parseAsync(params.queryParams);
 		} catch (error) {
-			if (isZodError(error)) throw new ValidationError("Invalid query parameters", error);
+			if (isZodError(error)) throw this.createValidationError(route, error, "query");
 			throw error;
 		}
 		let validatedBody = params.body;
-		if (route.bodySchema && params.body !== void 0) try {
-			validatedBody = await route.bodySchema.parseAsync(params.body);
+		if (route.bodySchema) try {
+			validatedBody = await this.parseBody(route, params.body);
 		} catch (error) {
-			if (isZodError(error)) throw new ValidationError("Invalid request body", error);
+			if (isZodError(error)) throw this.createValidationError(route, error, "body");
 			throw error;
 		}
 		const context = {
@@ -199,6 +224,31 @@ let RouteHandlerService = _RouteHandlerService = class RouteHandlerService {
 			sseFlushOnConnect: route.sseFlushOnConnect
 		};
 	}
+	async parseBody(route, body) {
+		const bodySchema = route.bodySchema;
+		if (!bodySchema) return body;
+		if (body === void 0) {
+			const omitted = await bodySchema.safeParseAsync(void 0);
+			if (omitted.success) return omitted.data;
+			const schemaType = getSchemaTypeName(unwrapOptionalNullable(bodySchema));
+			if (schemaType === "object" || schemaType === "ZodObject") {
+				const emptyObject = await bodySchema.safeParseAsync({});
+				if (emptyObject.success) return emptyObject.data;
+			}
+			throw omitted.error;
+		}
+		return bodySchema.parseAsync(body);
+	}
+	createValidationError(route, error, context) {
+		const hook = route.onValidationError ?? this.mastra.getServer()?.onValidationError;
+		if (hook) try {
+			const result = hook(error, context);
+			if (result) return new ValidationError(`Invalid ${VALIDATION_CONTEXT_LABELS[context]}`, error, result.status, result.body);
+		} catch (hookError) {
+			this.logger.error("Error in custom onValidationError hook", hookError);
+		}
+		return new ValidationError(`Invalid ${VALIDATION_CONTEXT_LABELS[context]}`, error, 400, formatZodError(error, VALIDATION_CONTEXT_LABELS[context]));
+	}
 	getRouteKey(method, path) {
 		return `${method.toUpperCase()}:${path}`;
 	}
@@ -232,9 +282,13 @@ RouteHandlerService = _RouteHandlerService = __decorate([
 */
 var ValidationError = class extends Error {
 	zodError;
-	constructor(message, zodError) {
+	status;
+	body;
+	constructor(message, zodError, status = 400, body = formatZodError(zodError, "request")) {
 		super(message);
 		this.zodError = zodError;
+		this.status = status;
+		this.body = body;
 		this.name = "ValidationError";
 	}
 };
@@ -243,11 +297,29 @@ var ValidationError = class extends Error {
 var _MastraExceptionFilter;
 let MastraExceptionFilter = _MastraExceptionFilter = class MastraExceptionFilter {
 	logger = new Logger(_MastraExceptionFilter.name);
-	catch(exception, host) {
+	async catch(exception, host) {
 		const ctx = host.switchToHttp();
 		const response = ctx.getResponse();
 		const request = ctx.getRequest();
 		if (response.headersSent) return;
+		if (exception instanceof ValidationError) {
+			response.status(exception.status).json(exception.body);
+			return;
+		}
+		const customResponse = getCustomHTTPExceptionResponse(exception);
+		if (customResponse) {
+			customResponse.headers.forEach((value, name) => {
+				if (name.toLowerCase() !== "set-cookie") response.setHeader(name, value);
+			});
+			const setCookies = customResponse.headers.getSetCookie();
+			if (setCookies.length > 0) response.setHeader("set-cookie", setCookies);
+			response.status(customResponse.status).send(Buffer.from(await customResponse.arrayBuffer()));
+			return;
+		}
+		if (exception instanceof HTTPException) {
+			response.status(exception.status).json({ error: exception.message });
+			return;
+		}
 		const normalized = this.normalizeError(exception);
 		const rawRequestId = request.headers["x-request-id"];
 		const requestId = (Array.isArray(rawRequestId) ? rawRequestId[0] : rawRequestId) || request.mastraRequestId;
@@ -10819,7 +10891,8 @@ let MastraController = class MastraController {
 		if (![
 			"POST",
 			"PUT",
-			"PATCH"
+			"PATCH",
+			"DELETE"
 		].includes(req.method)) return;
 		if ((req.headers["content-type"] || "").includes("multipart/form-data")) {
 			const maxFileSize = route.maxBodySize ?? this.options.bodyLimitOptions?.maxFileSize;
@@ -10829,7 +10902,7 @@ let MastraController = class MastraController {
 				allowedMimeTypes
 			});
 		}
-		return req.body;
+		return req.body === void 0 ? {} : req.body;
 	}
 };
 __decorate([
@@ -11029,15 +11102,20 @@ MastraAuthGuard = _MastraAuthGuard = __decorate([
 //#endregion
 //#region src/mastra-server.adapter.ts
 /**
-* Minimal Mastra server adapter wrapper for NestJS.
-* Provides MastraServerBase compatibility so getServerApp() works.
+* Mastra server adapter wrapper for NestJS.
+* Provides app access and delegates dynamic route registration to the catch-all controller.
 */
 var NestMastraServer = class extends MastraServerBase {
-	constructor(app) {
+	routeHandler;
+	constructor(app, routeHandler) {
 		super({
 			app,
 			name: "NestMastraServer"
 		});
+		this.routeHandler = routeHandler;
+	}
+	async registerRoute(_app, route, _options) {
+		this.routeHandler.registerRoute(route);
 	}
 };
 //#endregion
@@ -11048,20 +11126,31 @@ let MastraService = _MastraService = class MastraService {
 	options;
 	shutdownService;
 	httpAdapterHost;
+	routeHandler;
 	logger = new Logger(_MastraService.name);
 	serverAdapter;
-	constructor(mastra, options, shutdownService, httpAdapterHost) {
+	constructor(mastra, options, shutdownService, httpAdapterHost, routeHandler) {
 		this.mastra = mastra;
 		this.options = options;
 		this.shutdownService = shutdownService;
 		this.httpAdapterHost = httpAdapterHost;
+		this.routeHandler = routeHandler;
+		this.initializeServerAdapter();
+	}
+	onModuleInit() {
+		this.initializeServerAdapter();
+	}
+	initializeServerAdapter() {
+		if (this.serverAdapter) return;
 		const adapterType = this.httpAdapterHost?.httpAdapter?.getType?.();
 		if (adapterType && adapterType !== "express") throw new Error(`MastraModule requires NestJS to use the Express HTTP adapter. Received "${adapterType}". Install @nestjs/platform-express and bootstrap with the Express platform.`);
 		const app = this.httpAdapterHost?.httpAdapter?.getInstance?.();
-		if (app) {
-			this.serverAdapter = new NestMastraServer(app);
-			this.mastra.setMastraServer(this.serverAdapter);
-		} else this.logger.warn("Unable to register Mastra server adapter: HTTP adapter instance not available");
+		if (!app) {
+			this.logger.warn("Unable to register Mastra server adapter: HTTP adapter instance not available");
+			return;
+		}
+		this.serverAdapter = new NestMastraServer(app, this.routeHandler);
+		this.mastra.setMastraServer(this.serverAdapter);
 	}
 	/**
 	* Get the Mastra instance.
@@ -11100,11 +11189,13 @@ MastraService = _MastraService = __decorate([
 	__decorateParam(1, Inject(MASTRA_OPTIONS)),
 	__decorateParam(2, Inject(ShutdownService)),
 	__decorateParam(3, Inject(HttpAdapterHost)),
+	__decorateParam(4, Inject(RouteHandlerService)),
 	__decorateMetadata("design:paramtypes", [
 		Object,
 		Object,
 		typeof ShutdownService === "undefined" ? Object : ShutdownService,
-		typeof HttpAdapterHost === "undefined" ? Object : HttpAdapterHost
+		typeof HttpAdapterHost === "undefined" ? Object : HttpAdapterHost,
+		typeof RouteHandlerService === "undefined" ? Object : RouteHandlerService
 	])
 ], MastraService);
 //#endregion
@@ -11153,11 +11244,12 @@ let JsonBodyMiddleware = class JsonBodyMiddleware {
 		const maxSize = options.bodyLimitOptions?.maxSize ?? 10485760;
 		this.jsonParser = express.json({
 			limit: maxSize,
+			strict: false,
 			type: ["application/json", "application/*+json"]
 		});
 	}
 	use(req, res, next) {
-		if (req.body !== void 0 && Object.keys(req.body).length > 0) {
+		if (req.body !== void 0) {
 			next();
 			return;
 		}