@powerlines/schema 0.11.28 → 0.11.37

package/dist/reflection.mjs

@@ -1,236 +1,259 @@
+import { isJsonSchema, isJsonSchemaObject, isNullOnlyJsonSchema } from "./type-checks.mjs";
+import defu from "defu";
+import { isSetArray, isSetObject, isSetString, isUndefined } from "@stryke/type-checks";
 import { ReflectionClass, ReflectionKind, TypeNumberBrand } from "@powerlines/deepkit/vendor/type";
-import { isSetArray, isSetObject, isSetString } from "@stryke/type-checks";
 
 //#region src/reflection.ts
 /**
-* Maps a Deepkit numeric `brand` to the JTD numeric `type` keyword that best preserves the underlying width and signedness.
+* Maps a Deepkit numeric `brand` to JSON Schema `type` and `format`.
 *
-* @param brand - The Deepkit `TypeNumberBrand` of a numeric reflection, or `undefined` when no brand is set.
-* @returns The JTD numeric `type` keyword to use.
+* @remarks
+* This function takes a `TypeNumberBrand` (which represents specific numeric types in Deepkit, such as `integer`, `float`, `int8`, etc.) and returns a corresponding JSON Schema fragment that includes the appropriate `type`, `format`, and any relevant keywords (like `multipleOf` for integers). If the brand is not recognized, it defaults to a generic JSON Schema for numbers.
+*
+* @param brand - The Deepkit numeric brand to convert.
+* @return A JSON Schema fragment representing the numeric type corresponding to the provided brand.
 */
-function numberBrandToJtdType(brand) {
+function numberBrandToJsonSchema(brand) {
 	switch (brand) {
-		case TypeNumberBrand.integer: return "int32";
-		case TypeNumberBrand.int8: return "int8";
-		case TypeNumberBrand.uint8: return "uint8";
-		case TypeNumberBrand.int16: return "int16";
-		case TypeNumberBrand.uint16: return "uint16";
-		case TypeNumberBrand.int32: return "int32";
-		case TypeNumberBrand.uint32: return "uint32";
+		case TypeNumberBrand.integer: return {
+			type: "integer",
+			format: "int32",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.int8: return {
+			type: "integer",
+			format: "int8",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.uint8: return {
+			type: "integer",
+			format: "uint8",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.int16: return {
+			type: "integer",
+			format: "int16",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.uint16: return {
+			type: "integer",
+			format: "uint16",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.int32: return {
+			type: "integer",
+			format: "int32",
+			multipleOf: 1
+		};
+		case TypeNumberBrand.uint32: return {
+			type: "integer",
+			format: "uint32",
+			multipleOf: 1
+		};
 		case TypeNumberBrand.float:
-		case TypeNumberBrand.float32: return "float32";
-		case TypeNumberBrand.float64: return "float64";
+		case TypeNumberBrand.float32: return {
+			type: "number",
+			format: "float"
+		};
+		case TypeNumberBrand.float64: return {
+			type: "number",
+			format: "double"
+		};
 		case void 0:
-		default: return "float64";
+		default: return { type: "number" };
 	}
 }
+function withReflectionTags(reflection, schema) {
+	if (!isSetObject(reflection?.tags)) return schema;
+	const tags = reflection.tags;
+	if (isSetString(tags.title)) schema.title = tags.title;
+	if (isSetArray(tags.alias)) schema.alias = tags.alias;
+	if (!isUndefined(tags.hidden)) schema.hidden = tags.hidden;
+	if (!isUndefined(tags.ignore)) schema.ignore = tags.ignore;
+	if (!isUndefined(tags.internal)) schema.internal = tags.internal;
+	if (!isUndefined(tags.runtime)) schema.runtime = tags.runtime;
+	if (!isUndefined(tags.readonly)) schema.readOnly = tags.readonly;
+	return schema;
+}
+function withNullable(schema, nullable) {
+	if (!nullable) return schema;
+	const types = Array.isArray(schema.type) ? [...schema.type] : schema.type ? [schema.type] : [];
+	if (!types.includes("null")) types.push("null");
+	return {
+		...schema,
+		type: types.length === 1 ? types[0] : types
+	};
+}
 /**
-* Converts a Deepkit type reflection into a JSON Type Definition (RFC 8927) form suitable for AJV's JTD validator.
-*
-* @remarks
-* Some TypeScript constructs have no direct JTD equivalent and are handled with the closest available form:
-*
-* - `null` and `undefined` become the empty JTD form with `nullable: true`.
-* - Unions of primitives that cannot be expressed as a JTD enum collapse to the empty form (which validates any value).
-* - String/number/bigint literal unions are emitted as a JTD enum (non-string members are stringified, as JTD requires string enum members).
-* - Tuples are emitted as a JTD elements form whose element schema is the single tuple member type, or the empty schema for mixed tuples.
-* - `Date` is emitted as `{ type: "timestamp" }`.
-* - Discriminated unions of object literals (a shared string-literal tag property) are emitted as a JTD discriminator form.
-*
-* @param reflection - The Deepkit type reflection to convert.
-* @returns The corresponding JTD form, or `undefined` if the type cannot be represented.
+* Converts a Deepkit type reflection into a JSON Schema (draft-07) fragment.
 */
 function reflectionToJsonSchema(reflection) {
-	return reflectionToJtd(reflection);
+	return reflectionToJsonSchemaInner(reflection);
 }
-/**
-* Internal worker that performs the recursive Deepkit reflection → JTD conversion.
-*
-* @param reflection - The Deepkit type reflection to convert.
-* @returns The corresponding JTD form, or `undefined` if the type cannot be represented.
-*/
-function reflectionToJtd(reflection) {
-	const schema = {};
-	if (isSetObject(reflection?.tags)) {
-		const tags = reflection.tags;
-		schema.metadata = schema.metadata ?? {};
-		if (tags.readonly === true) schema.metadata.isReadonly = true;
-		if (tags.ignore === true) schema.metadata.isIgnored = true;
-		if (tags.internal === true) schema.metadata.isInternal = true;
-		if (tags.runtime === true) schema.metadata.isRuntime = true;
-		if (tags.hidden === true) schema.metadata.isHidden = true;
-		if (isSetArray(tags.alias)) schema.metadata.alias = tags.alias;
-		if (isSetString(tags.title)) schema.metadata.title = tags.title;
-	}
+function reflectionToJsonSchemaInner(reflection) {
 	switch (reflection.kind) {
 		case ReflectionKind.any:
 		case ReflectionKind.unknown:
 		case ReflectionKind.void:
-		case ReflectionKind.object: return {};
+		case ReflectionKind.object: return withReflectionTags(reflection, { name: reflection.typeName });
 		case ReflectionKind.never: return;
 		case ReflectionKind.undefined:
-		case ReflectionKind.null: return { nullable: true };
-		case ReflectionKind.string: return {
-			...schema,
-			type: "string"
-		};
-		case ReflectionKind.boolean: return {
-			...schema,
-			type: "boolean"
-		};
-		case ReflectionKind.number: return {
-			...schema,
-			type: numberBrandToJtdType(reflection.brand)
-		};
-		case ReflectionKind.bigint: return {
-			...schema,
-			type: "float64"
-		};
-		case ReflectionKind.regexp: return {
-			...schema,
-			type: "string"
-		};
+		case ReflectionKind.null: return withReflectionTags(reflection, {
+			type: "null",
+			name: reflection.typeName,
+			nullable: true
+		});
+		case ReflectionKind.string: return withReflectionTags(reflection, {
+			type: "string",
+			name: reflection.typeName
+		});
+		case ReflectionKind.boolean: return withReflectionTags(reflection, {
+			type: "boolean",
+			name: reflection.typeName
+		});
+		case ReflectionKind.number: return withReflectionTags(reflection, numberBrandToJsonSchema(reflection.brand));
+		case ReflectionKind.bigint: return withReflectionTags(reflection, {
+			type: "integer",
+			name: reflection.typeName,
+			format: "int64",
+			multipleOf: 1
+		});
+		case ReflectionKind.regexp: return withReflectionTags(reflection, {
+			type: "string",
+			name: reflection.typeName,
+			format: "regex",
+			contentMediaType: "text/regex"
+		});
 		case ReflectionKind.literal: {
 			const { literal } = reflection;
-			if (typeof literal === "string") return {
-				...schema,
-				enum: [literal]
-			};
-			if (typeof literal === "number" || typeof literal === "bigint") return {
-				...schema,
-				enum: [String(literal)]
-			};
-			if (typeof literal === "boolean") return {
-				...schema,
-				type: "boolean"
-			};
-			if (literal instanceof RegExp) return {
-				...schema,
-				type: "string"
-			};
-			return schema;
+			if (typeof literal === "string" || typeof literal === "number" || typeof literal === "boolean") return withReflectionTags(reflection, {
+				type: typeof literal,
+				name: reflection.typeName,
+				const: literal
+			});
+			if (typeof literal === "bigint") return withReflectionTags(reflection, {
+				type: "integer",
+				name: reflection.typeName,
+				format: "int64",
+				multipleOf: 1,
+				const: String(literal)
+			});
+			if (literal instanceof RegExp) return withReflectionTags(reflection, {
+				type: "string",
+				name: reflection.typeName,
+				format: "regex",
+				const: literal.source
+			});
+			return withReflectionTags(reflection, { name: reflection.typeName });
 		}
-		case ReflectionKind.templateLiteral: return {
-			...schema,
-			type: "string"
-		};
+		case ReflectionKind.templateLiteral: return withReflectionTags(reflection, { type: "string" });
 		case ReflectionKind.enum: {
-			const values = reflection.values.filter((value) => typeof value === "string" || typeof value === "number").map((value) => String(value));
-			const unique = Array.from(new Set(values));
-			if (unique.length === 0) return schema;
-			return {
-				...schema,
-				enum: unique
-			};
+			const values = reflection.values.filter((value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean");
+			if (values.length === 0) return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				description: reflection.description
+			});
+			return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				description: reflection.description,
+				enum: values
+			});
 		}
 		case ReflectionKind.array: {
-			const items = reflectionToJtd(reflection.type);
-			return {
-				...schema,
-				elements: items ?? {}
-			};
+			const items = reflectionToJsonSchemaInner(reflection.type);
+			return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				items: items ?? {}
+			});
 		}
 		case ReflectionKind.tuple: {
-			const items = reflection.types.map((member) => reflectionToJtd(member.type)).filter((item) => item !== void 0);
-			if (items.length === 0) return {
-				...schema,
-				elements: {}
-			};
-			if (items.length === 1) return {
-				...schema,
-				elements: items[0]
-			};
-			return {
-				...schema,
-				elements: {}
-			};
+			const items = reflection.types.map((member) => reflectionToJsonSchemaInner(member.type)).filter((item) => item !== void 0);
+			if (items.length <= 1) return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				items: items[0] ?? {}
+			});
+			return withReflectionTags(reflection, {
+				type: "array",
+				name: reflection.typeName,
+				items,
+				minItems: items.length,
+				maxItems: items.length
+			});
 		}
 		case ReflectionKind.union: {
-			const branches = reflection.types.map((inner) => reflectionToJtd(inner)).filter((item) => item !== void 0);
+			const branches = reflection.types.map((inner) => reflectionToJsonSchemaInner(inner)).filter(isJsonSchema);
 			const nullable = reflection.types.some((inner) => inner.kind === ReflectionKind.null || inner.kind === ReflectionKind.undefined);
-			const nonNull = branches.filter((b) => !isPureNullable(b));
-			if (nonNull.length === 0) return {
-				...schema,
+			const nonNull = branches.filter((branch) => branch.type !== "null" && !isNullOnlyJsonSchema(branch));
+			if (nonNull.length === 0) return withReflectionTags(reflection, {
+				type: "null",
 				nullable: true
-			};
-			if (nonNull.length === 1) {
-				const only = nonNull[0];
-				if (nullable) only.nullable = true;
-				return {
-					...schema,
-					...only
-				};
-			}
-			if (nonNull.every(isEnumForm)) {
-				const merged = Array.from(new Set(nonNull.flatMap((b) => b.enum)));
-				const form = {
-					...schema,
-					enum: merged
-				};
-				if (nullable) form.nullable = true;
-				return {
-					...schema,
-					...form
-				};
-			}
+			});
+			if (nonNull.length === 1) return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				...nonNull[0]
+			}), nullable);
+			const enumValues = nonNull.map((branch) => branch.const).filter((value) => value !== void 0);
+			if (enumValues.length === nonNull.length) return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				enum: enumValues
+			}), nullable);
 			const discriminator = tryReflectionDiscriminator(reflection.types);
-			if (discriminator) {
-				if (nullable) discriminator.nullable = true;
-				return {
-					...schema,
-					...discriminator
-				};
-			}
-			const fallback = {};
-			if (nullable) fallback.nullable = true;
-			return {
-				...schema,
-				...fallback
-			};
+			if (discriminator) return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				...discriminator
+			}), nullable);
+			return withNullable(withReflectionTags(reflection, {
+				name: reflection.typeName,
+				anyOf: nonNull
+			}), nullable);
 		}
 		case ReflectionKind.intersection: {
-			const members = reflection.types.map((inner) => reflectionToJtd(inner)).filter((item) => item !== void 0);
+			const members = reflection.types.map((inner) => reflectionToJsonSchemaInner(inner)).filter((item) => item !== void 0);
 			if (members.length === 0) return;
-			if (members.length === 1) return {
-				...schema,
-				...members[0]
-			};
-			if (members.every((member) => member && isPropertiesForm(member))) return mergePropertiesForms(members);
-			return {
-				...schema,
+			if (members.length === 1) return withReflectionTags(reflection, {
+				name: reflection.typeName,
 				...members[0]
-			};
+			});
+			if (members.every(isJsonSchemaObject)) return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				...mergeObjectSchemas(members)
+			});
+			return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				allOf: members
+			});
 		}
-		case ReflectionKind.promise: return reflectionToJtd(reflection.type);
-		case ReflectionKind.objectLiteral: return objectReflectionToJtd(reflection);
+		case ReflectionKind.promise: return reflectionToJsonSchemaInner(reflection.type);
+		case ReflectionKind.objectLiteral: return objectReflectionToJsonSchema(reflection);
 		case ReflectionKind.class: switch (reflection.classType?.name) {
-			case "Date": return {
-				...schema,
-				type: "timestamp"
-			};
-			case "RegExp": return {
-				...schema,
-				type: "string"
-			};
-			case "URL": return {
-				...schema,
-				type: "string"
-			};
+			case "Date": return withReflectionTags(reflection, {
+				type: "string",
+				format: "date-time"
+			});
+			case "RegExp": return withReflectionTags(reflection, {
+				type: "string",
+				format: "regex"
+			});
+			case "URL": return withReflectionTags(reflection, {
+				type: "string",
+				format: "uri"
+			});
 			case "Set": {
 				const itemType = reflection.arguments?.[0];
-				const items = itemType ? reflectionToJtd(itemType) : void 0;
-				return {
-					...schema,
-					elements: items ?? {}
-				};
+				return withReflectionTags(reflection, {
+					type: "array",
+					items: (itemType ? reflectionToJsonSchemaInner(itemType) : void 0) ?? {},
+					uniqueItems: true
+				});
 			}
 			case "Map": {
 				const valueType = reflection.arguments?.[1];
-				const values = valueType ? reflectionToJtd(valueType) : void 0;
-				return {
-					...schema,
-					values: values ?? {}
-				};
+				return withReflectionTags(reflection, {
+					type: "object",
+					additionalProperties: (valueType ? reflectionToJsonSchemaInner(valueType) : void 0) ?? true
+				});
 			}
 			case "Uint8Array":
 			case "Uint8ClampedArray":
@@ -242,12 +265,17 @@ function reflectionToJtd(reflection) {
 			case "Float32Array":
 			case "Float64Array":
 			case "BigInt64Array":
-			case "BigUint64Array": return {
-				...schema,
-				type: "string"
-			};
+			case "BigUint64Array": return withReflectionTags(reflection, {
+				type: "string",
+				format: "byte",
+				contentEncoding: "base64"
+			});
 			case void 0:
-			default: return objectReflectionToJtd(reflection);
+			default: return withReflectionTags(reflection, {
+				name: reflection.typeName,
+				description: reflection.description,
+				...objectReflectionToJsonSchema(reflection)
+			});
 		}
 		case ReflectionKind.symbol:
 		case ReflectionKind.property:
@@ -266,72 +294,26 @@ function reflectionToJtd(reflection) {
 		default: return;
 	}
 }
-/**
-* Tests whether a JTD form is an enum form.
-*
-* @param form - The JTD form to inspect.
-* @returns `true` if the form is a JTD enum form.
-*/
-function isEnumForm(form) {
-	return Array.isArray(form.enum);
-}
-/**
-* Tests whether a JTD form is a properties form (object).
-*
-* @param form - The JTD form to inspect.
-* @returns `true` if the form is a JTD properties form.
-*/
-function isPropertiesForm(form) {
-	return "properties" in form || "optionalProperties" in form;
-}
-/**
-* Tests whether a JTD form is the empty `{ nullable: true }` placeholder.
-*
-* @param form - The JTD form to inspect.
-* @returns `true` if the form has no shape constraints beyond `nullable`.
-*/
-function isPureNullable(form) {
-	return Object.keys(form).filter((k) => k !== "nullable" && k !== "metadata").length === 0 && form.nullable === true;
-}
-/**
-* Shallow-merges two JTD properties forms, unioning their `properties` and `optionalProperties` maps.
-*
-* @param forms - The JTD properties forms to merge.
-* @returns The merged JTD properties form.
-*/
-function mergePropertiesForms(forms) {
+function mergeObjectSchemas(schemas) {
 	const merged = {
+		type: "object",
 		properties: {},
-		optionalProperties: {}
+		required: []
 	};
-	for (const form of forms) {
-		const p = form.properties;
-		const o = form.optionalProperties;
-		if (p) Object.assign(merged.properties, p);
-		if (o) Object.assign(merged.optionalProperties, o);
-		if (form.additionalProperties) merged.additionalProperties = true;
+	for (const schema of schemas) {
+		if (schema.properties) merged.properties = defu(merged.properties, schema.properties);
+		if (schema.required) merged.required = Array.from(new Set([...merged.required ?? [], ...schema.required]));
+		if (schema.additionalProperties !== void 0) merged.additionalProperties = schema.additionalProperties;
 	}
-	const hasProperties = Object.keys(merged.properties).length > 0;
-	const hasOptional = Object.keys(merged.optionalProperties).length > 0;
-	const result = {};
-	if (hasProperties) result.properties = merged.properties;
-	else if (!hasOptional) result.properties = {};
-	if (hasOptional) result.optionalProperties = merged.optionalProperties;
-	if (merged.additionalProperties) result.additionalProperties = true;
-	return result;
+	if ((merged.required?.length ?? 0) === 0) delete merged.required;
+	return merged;
 }
-/**
-* Detects whether a Deepkit union represents a tagged union and, when so, emits the corresponding JTD discriminator form.
-*
-* @param types - The Deepkit reflection types that make up the union branches.
-* @returns A JTD discriminator form if every non-null branch is an object literal that shares a string-literal tag property, otherwise `undefined`.
-*/
 function tryReflectionDiscriminator(types) {
 	const nonNullTypes = types.filter((t) => t.kind !== ReflectionKind.null && t.kind !== ReflectionKind.undefined);
 	const objectBranches = nonNullTypes.filter((t) => t.kind === ReflectionKind.objectLiteral || t.kind === ReflectionKind.class);
 	if (objectBranches.length < 2 || objectBranches.length !== nonNullTypes.length) return;
 	let tagKey;
-	const mapping = {};
+	const branches = [];
 	for (const branch of objectBranches) {
 		const literalProps = [];
 		for (const member of branch.types) if ((member.kind === ReflectionKind.property || member.kind === ReflectionKind.propertySignature) && typeof member.name === "string" && member.type.kind === ReflectionKind.literal && typeof member.type.literal === "string") literalProps.push({
@@ -342,67 +324,77 @@ function tryReflectionDiscriminator(types) {
 		const first = literalProps[0];
 		if (!tagKey) tagKey = first.name;
 		else if (tagKey !== first.name) return;
-		const body = objectReflectionToJtd({
+		const body = objectReflectionToJsonSchema({
 			...branch,
 			types: branch.types.filter((member) => !((member.kind === ReflectionKind.property || member.kind === ReflectionKind.propertySignature) && member.name === tagKey))
 		});
-		if (!body || !isPropertiesForm(body)) return;
-		mapping[first.literal] = body;
+		if (!body || !isJsonSchemaObject(body)) return;
+		branches.push({
+			type: "object",
+			properties: {
+				[tagKey]: { const: first.literal },
+				...body.properties ?? {}
+			},
+			required: [tagKey, ...body.required ?? []],
+			additionalProperties: body.additionalProperties ?? false
+		});
 	}
 	if (!tagKey) return;
 	return {
-		discriminator: tagKey,
-		mapping
+		oneOf: branches,
+		discriminator: { propertyName: tagKey }
 	};
 }
-/**
-* Internal worker that produces a JTD properties form (or `values` form for index signatures alone) from a Deepkit object-like type.
-*
-* @param type - The class or object literal type whose members should be serialized.
-* @returns A JTD properties or values form describing the type's members.
-*/
-function objectReflectionToJtd(type) {
+function objectReflectionToJsonSchema(type) {
 	const reflection = ReflectionClass.from(type);
-	const schema = {};
-	schema.metadata = schema.metadata ?? {};
-	schema.metadata.isReadonly = reflection.isReadonly();
-	schema.metadata.isIgnored = reflection.isIgnored();
-	schema.metadata.isInternal = reflection.isInternal();
-	schema.metadata.isRuntime = reflection.isRuntime();
-	schema.metadata.isHidden = reflection.isHidden();
-	if (isSetString(reflection.databaseSchemaName)) schema.metadata.table = reflection.databaseSchemaName;
-	if (isSetString(reflection.getDescription())) schema.metadata.description = reflection.getDescription();
-	if (isSetArray(reflection.getAlias())) schema.metadata.alias = reflection.getAlias();
-	if (isSetString(reflection.getTitle())) schema.metadata.title = reflection.getTitle();
-	const properties = {};
-	const optionalProperties = {};
-	for (const propertyReflection of reflection.getProperties()) if (propertyReflection.getKind() === ReflectionKind.indexSignature) {
-		const valueSchema = reflectionToJtd(propertyReflection.type);
-		if (valueSchema) return {
-			...schema,
-			values: valueSchema,
-			additionalProperties: true
-		};
-	} else {
-		const property = reflectionToJtd(propertyReflection.type);
+	const schema = {
+		type: "object",
+		name: reflection.getName(),
+		description: reflection.getDescription(),
+		properties: {},
+		required: [],
+		readOnly: reflection.isReadonly(),
+		ignore: reflection.isIgnored(),
+		internal: reflection.isInternal(),
+		runtime: reflection.isRuntime(),
+		hidden: reflection.isHidden(),
+		primaryKey: reflection.getPrimaries().map((primary) => primary.getNameAsString()),
+		...isSetString(reflection.databaseSchemaName) ? { databaseSchemaName: reflection.databaseSchemaName } : {},
+		...isSetString(reflection.getName()) ? { name: reflection.getName() } : {},
+		...isSetString(reflection.getDescription()) ? { description: reflection.getDescription() } : {},
+		...isSetArray(reflection.getAlias()) ? { alias: reflection.getAlias() } : {},
+		...isSetString(reflection.getTitle()) ? { title: reflection.getTitle() } : {}
+	};
+	for (const propertyReflection of reflection.getProperties()) {
+		if (propertyReflection.getKind() === ReflectionKind.indexSignature) {
+			schema.additionalProperties = reflectionToJsonSchemaInner(propertyReflection.type) ?? true;
+			continue;
+		}
+		let property = reflectionToJsonSchemaInner(propertyReflection.type);
 		if (!property) continue;
-		property.metadata = property.metadata ?? {};
-		property.metadata.isReadonly = propertyReflection.isReadonly();
-		property.metadata.isIgnored = propertyReflection.isIgnored();
-		property.metadata.isInternal = propertyReflection.isInternal();
-		property.metadata.isRuntime = propertyReflection.isRuntime();
-		property.metadata.isPrimaryKey = propertyReflection.isPrimaryKey();
-		property.metadata.isHidden = propertyReflection.isHidden();
-		if (propertyReflection.hasDefault()) property.metadata.default = propertyReflection.getDefaultValue();
-		if (isSetString(propertyReflection.getDescription())) property.metadata.description = propertyReflection.getDescription();
-		if (isSetArray(propertyReflection.getAlias())) property.metadata.alias = propertyReflection.getAlias();
-		if (isSetString(propertyReflection.getTitle())) property.metadata.title = propertyReflection.getTitle();
-		if (propertyReflection.isOptional()) optionalProperties[propertyReflection.name] = property;
-		else properties[propertyReflection.name] = property;
+		property = {
+			...property,
+			name: propertyReflection.getNameAsString(),
+			description: propertyReflection.getDescription(),
+			readOnly: propertyReflection.isReadonly(),
+			ignore: propertyReflection.isIgnored(),
+			internal: propertyReflection.isInternal(),
+			runtime: propertyReflection.isRuntime(),
+			hidden: propertyReflection.isHidden(),
+			visibility: propertyReflection.isPublic() ? "public" : propertyReflection.isProtected() ? "protected" : propertyReflection.isPrivate() ? "private" : void 0,
+			...propertyReflection.hasDefault() ? { default: propertyReflection.getDefaultValue() } : {},
+			...isSetArray(propertyReflection.getGroups()) ? { tags: propertyReflection.getGroups() } : {},
+			...isSetArray(propertyReflection.getAlias()) ? { alias: propertyReflection.getAlias() } : {},
+			...isSetString(propertyReflection.getTitle()) ? { title: propertyReflection.getTitle() } : {}
+		};
+		if (propertyReflection.isNullable()) property = withNullable(property, true);
+		schema.properties ??= {};
+		schema.properties[propertyReflection.name] = property;
+		if (!propertyReflection.isOptional()) {
+			schema.required ??= [];
+			schema.required.push(propertyReflection.name);
+		}
 	}
-	if (Object.keys(properties).length > 0) schema.properties = properties;
-	else if (Object.keys(optionalProperties).length > 0) schema.optionalProperties = optionalProperties;
-	else schema.properties = {};
 	return schema;
 }