Function schemaTypeToJava

java/scripts/codegen/java.ts:520–672

(
    schema: JSONSchema7,
    required: boolean,
    context: string,
    propName: string,
    nestedTypes: Map<string, JavaClassDef>
)

}

function schemaTypeToJava(
    schema: JSONSchema7,
    required: boolean,
    context: string,
    propName: string,
    nestedTypes: Map<string, JavaClassDef>
): JavaTypeResult {
    const imports = new Set<string>();

    // Resolve $ref first — register standalone types for generation
    if (schema.$ref) {
        // Handle cross-schema $ref (e.g. "session-events.schema.json#/definitions/Foo")
        const crossSchemaMatch = schema.$ref.match(/^([^#]+)#\/definitions\/(.+)$/);
        if (crossSchemaMatch) {
            const [, schemaFile, typeName] = crossSchemaMatch;
            const externalDefs = crossSchemaDefinitions.get(schemaFile);
            if (externalDefs) {
                const resolved = externalDefs[typeName];
                if (resolved) {
                    // Save and swap currentDefinitions so recursive calls resolve against
                    // the external schema's definitions.
                    const savedDefs = currentDefinitions;
                    currentDefinitions = externalDefs;
                    const result = schemaTypeToJava(resolved, required, context, propName, nestedTypes);
                    currentDefinitions = savedDefs;
                    return result;
                }
            }
            // Fallback: extract just the type name and warn
            console.warn(`[codegen] Unresolved cross-schema $ref: ${schema.$ref}`);
            return { javaType: typeName, imports };
        }

        const name = schema.$ref.replace(/^#\/definitions\//, "");
        const resolved = currentDefinitions[name];
        if (resolved) {
            // Enum or object types → register for standalone generation, return ref name
            if ((resolved.type === "string" && resolved.enum) ||
                (resolved.type === "object" && resolved.properties)) {
                pendingStandaloneTypes.set(name, resolved);
                return { javaType: name, imports };
            }
            // Other types (primitives, arrays, maps, anyOf unions) → resolve and recurse
            return schemaTypeToJava(resolved, required, context, propName, nestedTypes);
        }
        // Unresolved $ref — return name as-is
        console.warn(`[codegen] Unresolved $ref: ${schema.$ref}`);
        return { javaType: name, imports };
    }

    if (schema.anyOf) {
        const hasNull = schema.anyOf.some((s) => typeof s === "object" && (s as JSONSchema7).type === "null");
        const nonNull = schema.anyOf.filter((s) => typeof s === "object" && (s as JSONSchema7).type !== "null");
        if (nonNull.length === 1) {
            const result = schemaTypeToJava(nonNull[0] as JSONSchema7, required && !hasNull, context, propName, nestedTypes);
            return result;
        }
        // Multi-branch anyOf: fall through to Object, matching the C# generator's