fix: check union case if there is an objectString

Author: Teyik0

src/compose.ts

@@ -1461,9 +1461,21 @@ export const composeHandler = ({
 
 						if (candidate) {
 							const isFirst = fileUnions.length === 0
+							// Handle case where schema is wrapped in a Union (e.g., ObjectString coercion)
+							let properties = candidate.schema?.properties ?? type.properties
+
+							// If no properties but schema is a Union, try to find the Object in anyOf
+							if (!properties && candidate.schema?.anyOf) {
+								const objectSchema = candidate.schema.anyOf.find((s: any) => s.type === 'object')
+								if (objectSchema) {
+									properties = objectSchema.properties
+								}
+							}
+
+							if (!properties) continue
 
 							const iterator = Object.entries(
-								type.properties
+								properties
 							) as [string, TSchema][]
 
 							let validator = isFirst ? '\n' : ' else '

src/replace-schema.ts

@@ -85,7 +85,7 @@ const replaceSchemaTypeFromOption = (
 			if (shouldTransform) {
 				return option.to(s) as TSchema;
 			}
-			return s
+            return s;
 		}
 
 		if (isRoot && option.rootOnly) {

src/schema.ts

@@ -126,11 +126,12 @@ export const hasAdditionalProperties = (
 /**
  * Resolve a schema that might be a model reference (string) to the actual schema
  */
-export const resolveSchema = (
-	schema: TAnySchema | string,
+ export const resolveSchema = (
+	schema: TAnySchema | string | undefined,
 	models?: Record<string, TAnySchema | StandardSchemaV1Like>,
 	modules?: TModule<any, any>
-): TAnySchema | StandardSchemaV1Like | undefined => {
+ ): TAnySchema | StandardSchemaV1Like | undefined => {
+    if (!schema) return undefined
 	if (typeof schema !== 'string') return schema
 
 	// Check modules first (higher priority)
@@ -141,7 +142,7 @@ export const resolveSchema = (
 
 	// Then check models
 	return models?.[schema]
-}
+ }
 
 export const hasType = (type: string, schema: TAnySchema): boolean => {
 	if (!schema) return false
@@ -456,12 +457,14 @@ export const getSchemaValidator = <
 			if (!schema) return undefined as any
 		}
 
+		const hasAdditionalCoerce = Array.isArray(additionalCoerce) ?
+		                                additionalCoerce.length > 0 : !!additionalCoerce
 		if (Kind in schema) {
 			if (schema[Kind] === 'Import') {
 				if (!hasRef(schema.$defs[schema.$ref])) {
 					schema = schema.$defs[schema.$ref]
 
-					if (coerce || additionalCoerce) {
+					if (coerce || hasAdditionalCoerce) {
 						schema = replaceSchema(schema as TSchema)
 						if ('$id' in schema && !schema.$defs) {
                             schema.$id = `${schema.$id}_coerced_${randomId()}`;
@@ -479,7 +482,7 @@ export const getSchemaValidator = <
 					})
 
 					schema = model.Import(id)
-				} else if (coerce || additionalCoerce)
+				} else if (coerce || hasAdditionalCoerce)
 					schema = replaceSchema(schema as TSchema)
 			}
 		}
@@ -694,16 +697,15 @@ export const getSchemaValidator = <
     		schema = replaceSchemaTypeFromManyOptions(schema, {
                 onlyFirst: "object",
                 from: t.Object({}),
-                to({ properties, ...options }) {
-                   	// If nothing is return, use the original schema
-                   	if (!properties) return { properties, ...options };
-                   	if ("additionalProperties" in schema) return { properties, ...options };
-
-                   	return t.Object(properties, {
-                  		...options,
-                  		additionalProperties: false,
-                   	});
-                },
+                to(schema) {
+                    if (!schema.properties) return schema;
+                    if ("additionalProperties" in schema) return schema;
+
+                    return t.Object(schema.properties, {
+                        ...schema,
+                        additionalProperties: false,
+                    });
+                }
             });
 	}
 

test/aot/has-type.test.ts

@@ -68,6 +68,21 @@ describe('Has Transform', () => {
 		expect(hasType('File', schema)).toBe(true)
 	})
 
+	it('found on direct Union', () => {
+		const schema = t.Union([
+			t.Object({
+			    id: t.Number(),
+			    liyue: t.File()
+			}),
+			t.Object({
+			    id: t.Number(),
+			    liyue: t.Number(),
+			}),
+		])
+
+		expect(hasType('File', schema)).toBe(true)
+	})
+
 	it('find in Import wrapping File', () => {
 		const schema = t.Module({
 			Avatar: t.File()