fn generate_interface_def()

in compiler-rs/openapi_to_clients_schema/src/types.rs [379:447]

• 60 lines of code
• 6 McCabe index (conditional complexity)

fn generate_interface_def(
    open_api: &OpenAPI,
    id: &str,
    base: BaseType,
    required: &[String],
    properties: &IndexMap<String, ReferenceOr<Box<Schema>>>,
    additional_properties: &Option<AdditionalProperties>,
    types: &mut Types,
) -> anyhow::Result<()> {
    // Regular type

    // FIXME: max_properties -- if == 1 indicates a container

    let required: HashSet<_> = required.iter().collect();
    if required.len() != required.len() {
        bail!("'required' in {id} has duplicate entries");
    }

    let mut props = Vec::new();
    for (name, value) in properties {
        let property = Property {
            name: name.clone(),
            typ: generate_value_of(open_api, value.into(), || format!("{}_{}", id, name), types)?,
            required: required.contains(&name),
            doc_id: None,
            doc_url: None,
            ext_doc_id: None,
            ext_doc_url: None,
            codegen_name: None, // FIXME: extension in workplace search
            description: None,
            aliases: Vec::default(),
            deprecation: None,
            container_property: false,
            es_quirk: None,
            server_default: None,
            availability: None,
        };

        props.push(property);
    }

    let mut typedef = Interface {
        base,
        properties: props,
        generics: Vec::default(),
        behaviors: Vec::default(),
        attached_behaviors: Vec::default(),
        inherits: None,
        implements: Vec::default(),
        variants: None,
        shortcut_property: None,
    };

    if let Some(props) = additional_properties {
        let prop_value: ValueOf = match props {
            AdditionalProperties::Any(_) => (&builtins::USER_DEFINED).into(),
            AdditionalProperties::Schema(schema) => {
                generate_value_of(open_api, schema.into(), || format!("{id}_props"), types)?
            }
        };
        typedef.behaviors.push(clients_schema::Inherits {
            typ: builtins::ADDITIONAL_PROPERTIES.clone(),
            generics: vec![prop_value],
        })
    };

    types.add(id, TypeDefinition::Interface(typedef));
    Ok(())
}