hasura/graphql-engine · warning · ArgumentIssue

argument {argument_name:?} has an issue: {issue:?}

Error message

argument {argument_name:?} has an issue: {issue:?}

What it means

An ArgumentIssue (collected into ArgumentsOutput.issues rather than aborting resolution) reporting that a model/command argument whose type is a boolean expression type has a nested problem with that boolean expression. The {issue:?} debug payload contains the underlying BooleanExpressionIssue detail. It means the argument itself resolved, but its boolean expression usage is invalid.

Source

Thrown at v3/crates/metadata-resolve/src/stages/arguments/types.rs:36

    Command(Qualified<CommandName>),
}

pub struct ArgumentsOutput {
    pub arguments: BTreeMap<ArgumentSource, IndexMap<ArgumentName, ArgumentInfo>>,
    pub issues: Vec<ArgumentIssue>,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct ArgumentInfo {
    pub argument_type: QualifiedTypeReference,
    pub description: Option<String>,
    pub argument_kind: ArgumentKind,
    pub type_representation: Option<ndc_models::TypeRepresentation>,
}

#[derive(Debug, Clone, thiserror::Error)]
pub enum ArgumentIssue {
    #[error("argument {argument_name:?} has an issue: {issue:?}")]
    BooleanExpressionIssue {
        argument_name: ArgumentName,
        issue: boolean_expressions::BooleanExpressionIssue,
    },
}

impl ContextualError for ArgumentIssue {
    fn create_error_context(&self) -> Option<error_context::Context> {
        match self {
            ArgumentIssue::BooleanExpressionIssue {
                argument_name: _,
                issue,
            } => issue.create_error_context(),
        }
    }
}

View on GitHub (pinned to 724551b9ae)

Solutions

1. Find the argument by name in the model/command OpenDD definition
2. Inspect the inner issue (formatted with {:?}) to identify the concrete boolean expression problem and fix that (type name, field, operator config, or type mapping)
3. Rebuild metadata and confirm the issue list is empty

// Validate boolean expression types referenced by arguments before resolving
if let Some(be) = argument.argument_type.as_boolean_expression() {
    assert_object_type_exists(&be.object_type)?;
    assert_all_operator_fields_exist(&be)?;
}

// Issues are collected, not thrown: inspect ArgumentsOutput.issues after resolution
let out = resolve_arguments(...)?;
for issue in &out.issues {
    if let ArgumentIssue::BooleanExpressionIssue { argument_name, issue } = issue {
        log::warn!("argument {argument_name} problematic: {issue:?}");
    }
}

When it happens

Trigger: Declaring a model argument with argumentType pointing at a boolean expression type whose object type, operators, or type mappings have issues. These issues are gathered per-argument during the arguments stage and reported in build output/warnings.

Common situations: Adding filter arguments to a model where the referenced boolean expression type references fields or types that are mismatched or unsupported; usually surfaced as build-time diagnostics listing the argument name and inner issue.

Related errors

• unknown type '{type_name}' used in object boolean expression
• unsupported type '{type_name}' used in object boolean expres
• unknown data connector {data_connector:} referenced in objec
• unknown data connector object type {data_connector_object_ty
• unknown field '{field_name:}' used in object boolean express

AI-assisted analysis of hasura/graphql-engine@724551b9ae (2026-08-28). Data as JSON: /api/errors/54c3c16c643d8de6. Report an issue: GitHub.