fn generate_schema_kind_one_of()

in compiler-rs/openapi_to_clients_schema/src/types.rs [306:347]

• 30 lines of code
• 3 McCabe index (conditional complexity)

fn generate_schema_kind_one_of(
    open_api: &OpenAPI,
    id: &str,
    one_of: &[ReferenceOr<Schema>],
    discriminator: &Option<Discriminator>,
    base: BaseType,
    types: &mut Types,
) -> anyhow::Result<()> {
    let filtered = one_of.iter().filter(|s| !open_api.is_not(s)).collect::<Vec<_>>();
    if filtered.len() == 1 {
        return generate_type(open_api, id, &filtered[0].into(), types).map(|_| ());
    }

    // Union type

    let union_of = generate_union_of(open_api, id, one_of, types)?;

    let mut variants: Option<TypeAliasVariants> = None;

    // TODO: do we want to allow untagged unions (those that are disambiguated by inspecting property names)?

    if let Some(discriminator) = discriminator {
        variants = Some(TypeAliasVariants::InternalTag(InternalTag {
            default_tag: None,
            tag: discriminator.property_name.clone(),
            non_exhaustive: false,
        }));

        // FIXME: need to set mappings, by setting the discriminator property in every variant to either
        // the type name or the key of in discriminator.mapping
    }

    let type_alias = TypeAlias {
        base,
        typ: ValueOf::UnionOf(union_of),
        generics: Vec::default(),
        variants, // May be set below
    };
    types.add(id, TypeDefinition::TypeAlias(type_alias));

    Ok(())
}