@mastra/schema-compat 1.3.12-alpha.0 → 1.3.12

package/dist/index.js

@@ -4970,6 +4970,13 @@ var SchemaCompatLayer = class {
 */
 function transformNullToUndefined(value, jsonSchema) {
 	if (value === null || value === void 0) return value;
+	const branches = jsonSchema.anyOf ?? jsonSchema.oneOf;
+	if (Array.isArray(branches)) {
+		const { anyOf: _anyOf, oneOf: _oneOf, ...parent } = jsonSchema;
+		const branch = findMatchingBranch(value, branches);
+		if (!branch) return "properties" in parent || "items" in parent ? transformNullToUndefined(value, parent) : value;
+		return transformNullToUndefined(value, mergeSchemas(parent, branch));
+	}
 	if (typeof value !== "object" || Array.isArray(value)) {
 		if (Array.isArray(value) && jsonSchema.items && typeof jsonSchema.items === "object") return value.map((item) => transformNullToUndefined(item, jsonSchema.items));
 		return value;
@@ -4984,6 +4991,58 @@ function transformNullToUndefined(value, jsonSchema) {
 	return result;
 }
 /**
+* Picks the non-null union branch (from `anyOf`/`oneOf`) whose shape matches the value,
+* e.g. the object branch of a `.nullable()` object. For objects, branches whose required
+* keys are missing or whose `const`/`enum` properties (discriminators) disagree are skipped.
+*/
+function findMatchingBranch(value, branches) {
+	const isArray = Array.isArray(value);
+	if (typeof value !== "object" && !isArray) return;
+	return branches.find((branch) => {
+		if (!branch || typeof branch !== "object") return false;
+		const types = Array.isArray(branch.type) ? branch.type : [branch.type];
+		if (isArray) {
+			if (!("items" in branch || types.includes("array"))) return false;
+			const items = branch.items;
+			return !items || typeof items !== "object" || value.every((item) => itemMatches(item, items));
+		}
+		if (!("properties" in branch || "anyOf" in branch || "oneOf" in branch || types.includes("object"))) return false;
+		return objectMatchesBranch(value, branch);
+	});
+}
+function itemMatches(item, schema) {
+	if (item === null || typeof item !== "object" || Array.isArray(item)) return true;
+	const branches = schema.anyOf ?? schema.oneOf;
+	if (Array.isArray(branches)) return findMatchingBranch(item, branches) !== void 0;
+	return objectMatchesBranch(item, schema);
+}
+function objectMatchesBranch(value, branch) {
+	if ((branch.required ?? []).some((key) => !(key in value))) return false;
+	const properties = branch.properties ?? {};
+	return Object.entries(properties).every(([key, prop]) => {
+		if (!prop || typeof prop !== "object" || !(key in value)) return true;
+		if ("const" in prop) return prop.const === value[key];
+		if (Array.isArray(prop.enum)) return prop.enum.includes(value[key]);
+		return true;
+	});
+}
+function mergeSchemas(parent, branch) {
+	const merged = {
+		...parent,
+		...branch
+	};
+	if (parent.items && !branch.items) merged.items = parent.items;
+	if (!parent.properties) return merged;
+	return {
+		...merged,
+		properties: {
+			...parent.properties,
+			...branch.properties
+		},
+		required: [.../* @__PURE__ */ new Set([...parent.required ?? [], ...branch.required ?? []])]
+	};
+}
+/**
 * Wraps a StandardSchemaWithJSON to transform null values to undefined for
 * optional fields before validation. This is a schema-agnostic solution for
 * OpenAI strict mode, which sends null for optional fields.