@mastra/schema-compat 1.3.8-alpha.1 → 1.3.9-alpha.0

package/dist/index.js

@@ -5058,6 +5058,39 @@ const allowedStringFormats = [
 	"ipv6",
 	"uuid"
 ];
+function unorderedArraysEqual(left, right, itemEquals) {
+	if (left.length !== right.length) return false;
+	const matched = /* @__PURE__ */ new Set();
+	return left.every((leftItem) => {
+		const matchIndex = right.findIndex((rightItem, index) => !matched.has(index) && itemEquals(leftItem, rightItem));
+		if (matchIndex === -1) return false;
+		matched.add(matchIndex);
+		return true;
+	});
+}
+function jsonValuesEqual(left, right) {
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => jsonValuesEqual(value, right[index]));
+	if (!left || !right || typeof left !== "object" || typeof right !== "object") return false;
+	const leftEntries = Object.entries(left);
+	const rightRecord = right;
+	return leftEntries.length === Object.keys(rightRecord).length && leftEntries.every(([key, value]) => Object.prototype.hasOwnProperty.call(rightRecord, key) && jsonValuesEqual(value, rightRecord[key]));
+}
+function schemaValuesEqual(left, right, keyword) {
+	if (keyword === "const" || keyword === "default" || keyword === "example" || keyword === "examples") return jsonValuesEqual(left, right);
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right)) return false;
+		if (keyword === "required" || keyword === "type") return unorderedArraysEqual(left, right, Object.is);
+		if (keyword === "enum") return unorderedArraysEqual(left, right, jsonValuesEqual);
+		if (keyword === "allOf" || keyword === "anyOf" || keyword === "oneOf") return unorderedArraysEqual(left, right, (leftItem, rightItem) => schemaValuesEqual(leftItem, rightItem));
+		return left.length === right.length && left.every((value, index) => schemaValuesEqual(value, right[index]));
+	}
+	if (!left || !right || typeof left !== "object" || typeof right !== "object") return false;
+	const leftEntries = Object.entries(left);
+	const rightRecord = right;
+	return leftEntries.length === Object.keys(rightRecord).length && leftEntries.every(([key, value]) => Object.prototype.hasOwnProperty.call(rightRecord, key) && schemaValuesEqual(value, rightRecord[key], key));
+}
 var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
 	getSchemaTarget() {
 		return `jsonSchema7`;
@@ -5187,41 +5220,89 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
 				if (!schema.required?.includes(key)) {
 					schema["x-optional"] = [...schema["x-optional"] || [], key];
 					schema.required?.push(key);
+					const objectKeywords = [
+						"properties",
+						"required",
+						"additionalProperties",
+						"x-optional"
+					];
+					const arrayKeywords = ["items"];
+					const genericConstraintKeywords = [
+						"const",
+						"enum",
+						"oneOf",
+						"not",
+						"if",
+						"then",
+						"else"
+					];
+					const branchConstraintKeywords = [
+						"anyOf",
+						"oneOf",
+						"not",
+						"if",
+						"then",
+						"else"
+					];
+					const typeSpecificKeywords = (type) => type === "object" ? objectKeywords : type === "array" ? arrayKeywords : [];
+					const isRedundantNullableUnion = (type) => {
+						if (!prop.anyOf || prop.anyOf.length !== 2) return false;
+						const nullBranches = prop.anyOf.filter((branch) => typeof branch !== "boolean" && branch.type === "null");
+						const valueBranches = prop.anyOf.filter((branch) => typeof branch !== "boolean" && branch.type !== "null");
+						if (nullBranches.length !== 1 || valueBranches.length !== 1) return false;
+						const valueBranch = valueBranches[0];
+						if (valueBranch.type !== type) return false;
+						return Object.entries(valueBranch).every(([keyword, value]) => {
+							if (keyword === "type") return true;
+							return keyword in prop && schemaValuesEqual(prop[keyword], value, keyword);
+						});
+					};
 					if (Array.isArray(prop.type)) {
 						const types = [...prop.type];
 						if (!types.includes("null")) types.push("null");
-						delete prop.anyOf;
+						const branchConstraints = {};
+						const propRecord = prop;
+						const branchConstraintRecord = branchConstraints;
+						for (const keyword of branchConstraintKeywords) if (keyword in prop) {
+							branchConstraintRecord[keyword] = propRecord[keyword];
+							delete propRecord[keyword];
+						}
 						delete prop.type;
 						if ("const" in prop) {
 							const constValue = prop.const;
-							prop.enum = !prop.enum || prop.enum.some((value) => JSON.stringify(value) === JSON.stringify(constValue)) ? [constValue, null] : [null];
+							prop.enum = !prop.enum || prop.enum.some((value) => jsonValuesEqual(value, constValue)) ? [constValue, null] : [null];
 							delete prop.const;
 						} else if (prop.enum && !prop.enum.includes(null)) prop.enum = [...prop.enum, null];
-						const objectKeywords = [
-							"properties",
-							"required",
-							"additionalProperties",
-							"x-optional"
-						];
-						const arrayKeywords = ["items"];
 						prop.anyOf = types.map((type) => {
 							if (type === "null") return { type: "null" };
 							const branch = { type };
-							const keywords = type === "object" ? objectKeywords : type === "array" ? arrayKeywords : [];
-							for (const keyword of keywords) if (keyword in prop) branch[keyword] = prop[keyword];
-							return branch;
+							for (const keyword of typeSpecificKeywords(type)) if (keyword in prop) branch[keyword] = prop[keyword];
+							return Object.assign(branch, branchConstraints);
 						});
 						for (const keyword of [...objectKeywords, ...arrayKeywords]) delete prop[keyword];
 					} else if (prop.type && prop.type !== "null") {
 						const originalType = prop.type;
-						const propSchema = { ...prop };
-						delete propSchema.anyOf;
-						delete propSchema.type;
-						delete prop.type;
-						prop.anyOf = [{
-							...propSchema,
-							type: originalType
-						}, { type: "null" }];
+						const keywords = typeSpecificKeywords(originalType);
+						if (keywords.length > 0) {
+							const branch = { type: originalType };
+							const preserveAnyOf = prop.anyOf && !isRedundantNullableUnion(originalType) ? prop.anyOf : void 0;
+							for (const keyword of [...keywords, ...genericConstraintKeywords]) if (keyword in prop) {
+								branch[keyword] = prop[keyword];
+								delete prop[keyword];
+							}
+							if (preserveAnyOf) branch.anyOf = preserveAnyOf;
+							delete prop.type;
+							prop.anyOf = [branch, { type: "null" }];
+						} else {
+							const propSchema = {
+								...prop,
+								type: originalType
+							};
+							if (isRedundantNullableUnion(originalType)) delete propSchema.anyOf;
+							for (const keyword of [...genericConstraintKeywords, "anyOf"]) delete prop[keyword];
+							delete prop.type;
+							prop.anyOf = [propSchema, { type: "null" }];
+						}
 					}
 				}
 			}