@mastra/server 1.79.0-alpha.1 → 1.79.0-alpha.10

package/dist/{route-builder-lBil8Cvo.js → route-builder-BfQYtclb.js}

@@ -1,10 +1,10 @@
-import { a as require_json_schema_traverse, n as standardSchemaToJSONSchema } from "./schema-e0VHpMt0-CvPvLS06.js";
+import { a as require_json_schema_traverse, n as standardSchemaToJSONSchema } from "./schema-e0VHpMt0-CVP5Hnxy.js";
 import { ZodArray, ZodNullable, ZodObject, ZodOptional, ZodRecord, z } from "zod/v4";
 import { toStandardSchema } from "@mastra/core/schema";
 import { zodToJsonSchema } from "@mastra/core/utils/zod-to-json";
 import { ZodFirstPartyTypeKind } from "zod/v3";
 import { z as z$2 } from "zod";
-//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod-from-json-schema/0.5.2/6d17c02444d8741339c17b6813a2702a4dfeb014f03ed377f311bb739f609aba/node_modules/zod-from-json-schema/dist/index.mjs
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/zod-from-json-schema/0.5.2/938b1a90632b5c19aade6e212477c764befeb6d6e1cdb7cfde7de2557cd03f99/node_modules/zod-from-json-schema/dist/index.mjs
 var TypeHandler = class {
 	apply(types, schema) {
 		if (!schema.type) return;
@@ -3440,7 +3440,7 @@ createIdGenerator({
 	size: 24
 });
 __export({}, {
-	object: () => object,
+	object: () => object$1,
 	text: () => text
 });
 var text = () => ({
@@ -3456,7 +3456,7 @@ var text = () => ({
 		return text2;
 	}
 });
-var object = ({ schema: inputSchema }) => {
+var object$1 = ({ schema: inputSchema }) => {
 	const schema = asSchema(inputSchema);
 	return {
 		type: "object",
@@ -3835,10 +3835,107 @@ function generateRouteOpenAPI({ method, path, summary, description, tags = [], p
 function schemaToJsonSchema(schema) {
 	return standardSchemaToJSONSchema(toStandardSchema(schema));
 }
+const DEFINITION_KEYWORDS = ["$defs", "definitions"];
+const GENERATED_DEFINITION_NAME = /^__schema\d+$/;
+function createComponentSchemas() {
+	return Object.create(null);
+}
+function escapeJsonPointer(segment) {
+	return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function componentRef(name) {
+	return `#/components/schemas/${escapeJsonPointer(name)}`;
+}
+function toComponentName(name) {
+	return GENERATED_DEFINITION_NAME.test(name) ? "Schema" : name.replace(/[^a-zA-Z0-9.\-_]/g, "_") || "Schema";
+}
+function containsRootRef(node) {
+	if (Array.isArray(node)) return node.some(containsRootRef);
+	if (!node || typeof node !== "object") return false;
+	return Object.entries(node).some(([key, value]) => key === "$ref" ? value === "#" : containsRootRef(value));
+}
+function rewriteRefs(node, rewrite) {
+	if (Array.isArray(node)) return node.map((child) => rewriteRefs(child, rewrite));
+	if (!node || typeof node !== "object") return node;
+	const result = {};
+	for (const [key, value] of Object.entries(node)) result[key] = key === "$ref" && typeof value === "string" ? rewrite(value) : rewriteRefs(value, rewrite);
+	return result;
+}
+/**
+* Moves the local `$defs`/`definitions` of a standalone JSON Schema into the shared
+* `components.schemas` map and rewrites its local refs to `#/components/schemas/<name>`.
+*
+* A converted schema references its own definitions as `#/definitions/__schema0` (or
+* `#/$defs/Invoice`, or `#` for a recursive root), which only resolves while the schema is
+* the document. Once embedded in the OpenAPI document `#` is the document root, so the refs
+* would dangle. Identical definitions are shared; different ones get a unique name.
+*/
+function hoistSchemaDefinitions(schema, components) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+	const root = { ...schema };
+	const members = [];
+	for (const keyword of DEFINITION_KEYWORDS) {
+		const definitions = root[keyword];
+		if (!definitions || typeof definitions !== "object") continue;
+		delete root[keyword];
+		for (const [name, body] of Object.entries(definitions)) members.push({
+			pointer: `#/${keyword}/${escapeJsonPointer(name)}`,
+			base: toComponentName(name),
+			body
+		});
+	}
+	const rootIsReferenced = containsRootRef(root) || members.some((member) => containsRootRef(member.body));
+	if (rootIsReferenced) members.push({
+		pointer: "#",
+		base: "Schema",
+		body: root
+	});
+	if (members.length === 0) return schema;
+	const names = members.map((member) => member.base);
+	const suffixes = members.map(() => 1);
+	const rewrite = (ref) => {
+		for (let i = 0; i < members.length; i++) {
+			const { pointer } = members[i];
+			if (ref === pointer) return componentRef(names[i]);
+			if (pointer !== "#" && ref.startsWith(`${pointer}/`)) return componentRef(names[i]) + ref.slice(pointer.length);
+		}
+		return ref;
+	};
+	let bodies;
+	for (;;) {
+		bodies = members.map((member) => JSON.stringify(rewriteRefs(member.body, rewrite)));
+		const taken = /* @__PURE__ */ new Set();
+		let conflict = false;
+		members.forEach((_, i) => {
+			const name = names[i];
+			const existing = components[name];
+			if (taken.has(name) || existing !== void 0 && JSON.stringify(existing) !== bodies[i]) {
+				suffixes[i] += 1;
+				names[i] = `${members[i].base}_${suffixes[i]}`;
+				conflict = true;
+			}
+			taken.add(name);
+		});
+		if (!conflict) break;
+	}
+	members.forEach((_, i) => {
+		components[names[i]] ??= JSON.parse(bodies[i]);
+	});
+	return rootIsReferenced ? { $ref: componentRef(names[names.length - 1]) } : rewriteRefs(root, rewrite);
+}
+function toComponentSchema(schema, components) {
+	const jsonSchema = schemaToJsonSchema(schema);
+	return components ? hoistSchemaDefinitions(jsonSchema, components) : jsonSchema;
+}
+function resolveComponentRef(schema, components) {
+	if (!components) return schema;
+	if (typeof schema?.$ref !== "string" || !schema.$ref.startsWith("#/components/schemas/")) return schema;
+	return components[schema.$ref.slice(21).replace(/~1/g, "/").replace(/~0/g, "~")] ?? schema;
+}
 /**
 * Converts an OpenAPI route spec with PublicSchema to one with JSON Schema
 */
-function convertToJsonSchema(spec) {
+function convertToJsonSchema(spec, components) {
 	const converted = {
 		summary: spec.summary,
 		description: spec.description,
@@ -3848,7 +3945,7 @@ function convertToJsonSchema(spec) {
 	};
 	const parameters = [];
 	if (spec.requestParams?.path) {
-		const properties = schemaToJsonSchema(spec.requestParams.path).properties || {};
+		const properties = resolveComponentRef(toComponentSchema(spec.requestParams.path, components), components).properties || {};
 		Object.entries(properties).forEach(([name, schema]) => {
 			parameters.push({
 				name,
@@ -3860,7 +3957,7 @@ function convertToJsonSchema(spec) {
 		});
 	}
 	if (spec.requestParams?.query) {
-		const querySchema = schemaToJsonSchema(spec.requestParams.query);
+		const querySchema = resolveComponentRef(toComponentSchema(spec.requestParams.query, components), components);
 		const properties = querySchema.properties || {};
 		const required = querySchema.required || [];
 		Object.entries(properties).forEach(([name, schema]) => {
@@ -3876,11 +3973,11 @@ function convertToJsonSchema(spec) {
 	if (parameters.length > 0) converted.parameters = parameters;
 	if (spec.requestBody?.content?.["application/json"]?.schema) converted.requestBody = {
 		required: true,
-		content: { "application/json": { schema: schemaToJsonSchema(spec.requestBody.content["application/json"].schema) } }
+		content: { "application/json": { schema: toComponentSchema(spec.requestBody.content["application/json"].schema, components) } }
 	};
 	Object.entries(spec.responses).forEach(([statusCode, response]) => {
 		converted.responses[statusCode] = { description: response.description };
-		if (response.content?.["application/json"]?.schema) converted.responses[statusCode].content = { "application/json": { schema: schemaToJsonSchema(response.content["application/json"].schema) } };
+		if (response.content?.["application/json"]?.schema) converted.responses[statusCode].content = { "application/json": { schema: toComponentSchema(response.content["application/json"].schema, components) } };
 	});
 	return converted;
 }
@@ -3892,11 +3989,12 @@ function convertToJsonSchema(spec) {
 */
 function generateOpenAPIDocument(routes, info) {
 	const paths = Object.create(null);
+	const componentSchemas = createComponentSchemas();
 	routes.forEach((route) => {
 		if (!route.openapi) return;
 		const openapiPath = route.path.replace(/:(\w+)/g, "{$1}");
 		if (!paths[openapiPath]) paths[openapiPath] = Object.create(null);
-		paths[openapiPath][route.method.toLowerCase()] = convertToJsonSchema(route.openapi);
+		paths[openapiPath][route.method.toLowerCase()] = convertToJsonSchema(route.openapi, componentSchemas);
 	});
 	return {
 		openapi: "3.1.0",
@@ -3905,7 +4003,8 @@ function generateOpenAPIDocument(routes, info) {
 			version: info.version,
 			description: info.description
 		},
-		paths
+		paths,
+		...Object.keys(componentSchemas).length > 0 && { components: { schemas: componentSchemas } }
 	};
 }
 /**
@@ -3914,18 +4013,25 @@ function generateOpenAPIDocument(routes, info) {
 * so it already has the standard OpenAPI structure (parameters, requestBody, responses, etc.).
 *
 * @param routes - Array of ApiRoute objects with optional openapi specifications
+* @param componentSchemas - The document's `components.schemas` map. Nested schema definitions are
+* hoisted into it and referenced as `#/components/schemas/<name>`, so the caller must serve it.
+* When omitted, schemas are left as converted (definitions stay nested), so no ref can point at a
+* component the caller never serves. Callers that serve the returned paths in an OpenAPI document
+* should pass a map and emit it as `components.schemas`; otherwise refs stay schema-relative
+* (for example `#/$defs/Invoice`) and do not resolve from the document root.
 * @returns OpenAPI paths object to be merged into the main spec
 */
-function convertCustomRoutesToOpenAPIPaths(routes) {
-	const paths = {};
+function convertCustomRoutesToOpenAPIPaths(routes, componentSchemas) {
+	const paths = Object.create(null);
+	const hoist = (schema) => componentSchemas ? hoistSchemaDefinitions(schema, componentSchemas) : schema;
 	for (const route of routes) {
 		if (!route.openapi || route.openapi.hide) continue;
 		if (route.method === "ALL") continue;
 		const openapiPath = route.path.replace(/:(\w+)/g, "{$1}");
-		if (!paths[openapiPath]) paths[openapiPath] = {};
+		if (!paths[openapiPath]) paths[openapiPath] = Object.create(null);
 		const method = route.method.toLowerCase();
 		if (isSchemaApiRoute(route)) {
-			paths[openapiPath][method] = convertToJsonSchema(route.openapi);
+			paths[openapiPath][method] = convertToJsonSchema(route.openapi, componentSchemas);
 			continue;
 		}
 		const openapi = route.openapi;
@@ -3941,7 +4047,7 @@ function convertCustomRoutesToOpenAPIPaths(routes) {
 		if (openapi.parameters && Array.isArray(openapi.parameters)) operation.parameters = openapi.parameters.map((param) => {
 			if (param.schema && typeof param.schema === "object" && "_def" in param.schema) return {
 				...param,
-				schema: zodToJsonSchema(param.schema, "openApi3", "none")
+				schema: hoist(zodToJsonSchema(param.schema, "openApi3", "none"))
 			};
 			return param;
 		});
@@ -3952,7 +4058,7 @@ function convertCustomRoutesToOpenAPIPaths(routes) {
 				operation.requestBody.content = {};
 				for (const [mediaType, mediaContent] of Object.entries(requestBody.content)) if (mediaContent?.schema && typeof mediaContent.schema === "object" && "_def" in mediaContent.schema) operation.requestBody.content[mediaType] = {
 					...mediaContent,
-					schema: zodToJsonSchema(mediaContent.schema, "openApi3", "none")
+					schema: hoist(zodToJsonSchema(mediaContent.schema, "openApi3", "none"))
 				};
 				else operation.requestBody.content[mediaType] = mediaContent;
 			}
@@ -3970,7 +4076,7 @@ function convertCustomRoutesToOpenAPIPaths(routes) {
 					operation.responses[statusCode].content = {};
 					for (const [mediaType, mediaContent] of Object.entries(response.content)) if (mediaContent?.schema && typeof mediaContent.schema === "object" && "_def" in mediaContent.schema) operation.responses[statusCode].content[mediaType] = {
 						...mediaContent,
-						schema: zodToJsonSchema(mediaContent.schema, "openApi3", "none")
+						schema: hoist(zodToJsonSchema(mediaContent.schema, "openApi3", "none"))
 					};
 					else operation.responses[statusCode].content[mediaType] = mediaContent;
 				}
@@ -4214,4 +4320,4 @@ function createPublicRoute(config) {
 //#endregion
 export { wrapSchemaForQueryParams as a, schemaToJsonSchema as c, pickParams as i, createRoute as n, convertCustomRoutesToOpenAPIPaths as o, jsonQueryParam as r, generateOpenAPIDocument as s, createPublicRoute as t };
 
-//# sourceMappingURL=route-builder-lBil8Cvo.js.map
+//# sourceMappingURL=route-builder-BfQYtclb.js.map