Infrahub SDK Bug: Object Template Creation With Optionals

Nov 13, 2025 by Alex Johnson 58 views

Bug: Creating an Object with an Object Template with Optional Attributes Fails to Set the Optional Attributes

Introduction

This article addresses a critical bug encountered while creating objects using object templates within the Infrahub SDK, specifically version 1.15.1. The issue arises when dealing with optional attributes, leading to unexpected behavior and hindering the correct application of object templates. This bug significantly impacts users relying on object templates for efficient and accurate object creation in their infrastructure management workflows. Understanding the root cause, reproducing the bug, and implementing the suggested solution are essential for maintaining data integrity and streamlining operations within the Infrahub ecosystem. In this comprehensive analysis, we will delve into the current behavior, expected behavior, steps to reproduce the issue, and provide additional information to aid in resolving this bug effectively.

Component

The primary component affected by this bug is the Python SDK. This indicates that the issue stems from how the Python SDK handles object template creation, particularly concerning optional attributes. The Python SDK is crucial for interacting with the Infrahub platform, and any bug within it can have widespread implications for users relying on it for their infrastructure management tasks.

Infrahub SDK Version

The specific version of the Infrahub SDK where this bug manifests is 1.15.1. Identifying the version is crucial for developers and users to determine if they are affected by this bug and to apply the appropriate fixes or workarounds. This also helps in tracking the bug's lifecycle and ensuring that it is resolved in future releases.

Current Behavior

The current behavior exhibits a flaw where the SDK incorrectly provides an override value to the backend when an optional relationship of cardinality one is used with object templates. This override prevents the backend from applying the value specified in the object template. This behavior can lead to inconsistencies and errors in the created objects, as the optional attributes are not being set as intended. This issue arises both when using the UI to create objects and when loading data from object files, making it a pervasive problem.

To illustrate, consider the following GraphQL mutation generated by the UI:

mutation {
  DcimDeviceCreate(
    data: {object_template: {id: "18779f71-9564-3911-3bc2-1065c8cd8363"}, name: {value: "123123"}, location: {id: "18779f71-e8aa-55c1-3bc0-1065ebd40353"}}
  ) {
    object {
      id
      display_label
      hfid
      __typename
    }
    __typename
  }
}

However, the SDK generates a different GraphQL mutation:

mutation {
    DcimDeviceUpsert(
        data: {
            status: {
                value: "active"
            }
            name: {
                value: "123123"
            }
            index: {
                value: 1
            }
            mlag_domain: null
            object_template: {
                id: "18779f71-55f1-390f-3bcf-10652e6ca9d3"
            }
            platform: {
                id: "test"
            }
            primary_address: null
            location: {
                id: "18779f72-1586-2058-3bc3-106527497af8"
            }
            device_type: null
        }
    ){
        ok
        object {
            id
        }
    }
}

Notice the presence of numerous null fields in the SDK-generated mutation. These null values override the values that should be applied from the object template, leading to the issue. This behavior is consistent even when using object files to load data, indicating a fundamental problem in how the SDK handles optional attributes during object creation.

Expected Behavior

The expected behavior is that the SDK should ignore optional fields and not instantiate them when creating a node. Since the backend does not require these optional fields, there is no need for the client to include them in the mutation. This would allow the backend to correctly apply the values provided by the object template, ensuring that the created objects are consistent and accurate. By omitting these optional fields, the SDK would align with the backend's requirements and prevent the override issue.

Steps to Reproduce

To reproduce this bug, follow these steps:

Load Infrahub with the base schema from the Schema library: https://github.com/opsmill/schema-library/blob/main/base/dcim.yml#L87.
Create some manufacturers and device_types. This step ensures that you have the necessary data to create device types later.
Create a device type using an object file. Use the following object file content:

---
apiVersion: infrahub.app/v1
kind: Object
spec:
  kind: DcimDevice
  data:
    # Paris HQ Building - Cisco Core Routers
    - name: CoreRouter1
      object_template: CISCO-ASR1006-CORE
      location: hq-01
      status: active
      index: 1
    - name: CoreRouter2
      object_template: CISCO-ASR1006-CORE
      location: hq-01
      status: active
      index: 2

By following these steps, you should be able to reproduce the bug where optional attributes are not correctly set when creating objects from object templates.

Impact and Mitigation

The impact of this bug is significant, as it leads to inconsistencies in the created objects and undermines the purpose of using object templates for standardized object creation. Users may experience difficulties in managing their infrastructure due to inaccurate or incomplete data. Mitigating this bug requires either a fix in the SDK to prevent the inclusion of optional fields or a workaround to manually ensure that optional attributes are correctly set after object creation. This bug affects the reliability of infrastructure management and introduces extra overhead into the system. By understanding this bug and how to reproduce it, developers and users are better equipped to tackle the difficulties that arise from it.

Proposed Solution

The proposed solution is to modify the Infrahub SDK to exclude optional fields from the GraphQL mutation when creating objects from object templates. This would prevent the SDK from overriding the values provided by the object template and ensure that the backend correctly applies the intended values. By implementing this change, the SDK would align with the backend's requirements and resolve the bug effectively.

Conclusion

In conclusion, the bug in Infrahub SDK version 1.15.1, which causes optional attributes to be incorrectly handled during object template creation, poses a significant challenge for users relying on the SDK for infrastructure management. The SDK's current behavior of overriding optional fields with null values prevents the backend from correctly applying the values specified in the object template. The expected behavior is for the SDK to ignore these optional fields, allowing the backend to manage them as intended. By following the steps to reproduce the bug and understanding the proposed solution, developers and users can work together to address this issue and ensure the integrity of their infrastructure data. Addressing this bug will greatly enhance the reliability and efficiency of the Infrahub platform, streamlining operations and improving the overall user experience. For more information on GraphQL mutations and best practices, refer to the GraphQL Foundation.