Builderius Beta 1.1.1 Patch Release

This update brings important bug fixes and new GraphQL features that make working with hierarchical data much easier. Both free and Pro versions receive improvements.

What’s New in Builderius Free 1.1.1-beta

Bug Fixes

• HTML tag changes now work properly – Fixed issues when switching between element types (like changing a div to an article)
• Template conditions fixed – Post category and tag-based conditions now work correctly for template assignments

Enhanced Release Control

Release control has been expanded to include posts and pages alongside existing template controls. You can now selectively include or exclude any content type when creating a release.

What’s new: Previously you could only control template inclusion. Now you can also:

• Choose specific posts and pages for each release
• Test individual content without affecting other pages
• Keep draft posts private while publishing finished content
• Full granular control over what goes live

What’s New in Builderius Pro 1.0.1-beta

Bug Fix

• CSS sync improvements – Better synchronization between visual controls and code editor for advanced CSS properties

New Features

Hierarchical Data Queries – Extended children field and @recursive directive from navigation to all hierarchical taxonomies

Inline Data Transformations – New @transform directive for cleaner query structure

Working with Hierarchical Taxonomies

WordPress has hierarchical data beyond just menus – categories, custom taxonomies, and more can have parent-child relationships. Builderius now makes it easy to query these hierarchies with GraphQL.

The children field enables hierarchical queries, while the @recursive directive makes them scalable. Having both gives you complete control over how deep you want to query.

Basic Parent-Child Queries with children

The children field enables you to query parent categories and their immediate children:

{
  terms_query (
	 arguments: {
		taxonomy: "category"
	}
  ) {
    name
    children {
      name
    }
  }
}

What this does: Gets all parent categories and shows their direct child categories. Perfect when you want precise control over how many levels to include.

Multiple Levels with Nested children

Need grandchildren? Nest another children field for explicit control over each level:

{
  terms_query (
	 arguments: {
		taxonomy: "category"
	}
  ) {
    name
    children {
      name
      children {
        name
      }
    }
  }
}

Use case: When you need exactly 3 levels for structures like “Electronics > Computers > Laptops”

Unlimited Depth with @recursive

When you don’t know how deep your taxonomy goes,

@recursive

makes queries scalable by automatically traversing all levels:

{
  terms_query (
	 arguments: {
		taxonomy: "category"
	}
  ) {
    name
    children @recursive {
      name
    }
  }
}

Why @recursive matters: Makes hierarchical queries scalable – one query gets your entire category tree, no matter how many levels deep. Perfect when the depth varies or is unknown.

Control: Choose Your Approach

Use children when you need:

• Precise control over depth (exactly 2 or 3 levels)
• Different fields at different levels
• Performance optimization for known structures

Use @recursive when you need:

• Unknown or varying depth
• Scalable queries that adapt to your data
• Simple traversal of entire hierarchies

Having both gives you complete control over how you query hierarchical data based on your specific needs.

Inline Data Transformations

Previously, transforming data required creating separate fields. Now you can transform data directly where you use it.

The Old Way

Before, you needed expression_result() fields for transformations:

{
  post {
    post_title
  }
  loud_title: expression_result(expression: "upper(post.post_title)")
}

The New Way with @transform

Now transform data inline with the @transform directive:

{
  post {
    post_title @transform(expression: "upper(post_title)")
  }
}

Real-World Examples

Text transformations:

# Make titles uppercase
post_title @transform(expression: "upper(post_title)")

# Format dates
post_date @transform(expression: "date('F j, Y', strtotime(post_date))")

# Limit post content length
post_content @transform(expression: "limit_words(post_content, 25)")

Why @transform is better:

• Cleaner queries – No separate result fields cluttering your schema
• More readable – Transform exactly where you need the data
• Less complexity – One field instead of two for transformed data
• Better organization – Keep transformations close to the data they modify

Getting Started

For hierarchical data: Start with basic children queries, then add @recursive when you need unlimited depth.

For transformations: Replace your expression_result() fields with @transform directives on existing fields.

For releases: Use the new toggle controls to select exactly what you want to publish.

Upcoming This Week

Additional features from the current roadmap:

• AI training materials and complete GraphQL schema
• Updated website with public roadmap
• Video tutorials for GraphQL and AI training

Pricing reminder: Early bird pricing ends October 1st.

Builderius 1.1.1 is available now through WordPress admin or direct download from builderius.io