[Bug]: PHP Warning: Array to string conversion in class-sitemaps-cache.php

[gab12]

Prerequisites

• I've read and understood the contribution guidelines.
• I've searched for any related issues and avoided creating a duplicate issue.

Summary

We are regularly encountering the following PHP warning with Yoast SEO 28.2:

PHP Warning [2]: Array to string conversion

The warning originates from:
wp-content/plugins/wordpress-seo/inc/sitemaps/class-sitemaps-cache.php

at approximately line 206, in the invalidate_helper() method.

Environment

Plugin: Yoast SEO 28.2
WooCommerce 11.0.1
PHP: 8.3
WordPress: WordPress 7.0.3

The issue occurs repeatedly during automated WooCommerce product updates.

Error

The reported error is:

PHP Error [2] Array to string conversion

Location:

wp-content/plugins/wordpress-seo/inc/sitemaps/class-sitemaps-cache.php

The relevant code is:

public static function invalidate_helper( $unused, $type ) {

    if (
        WPSEO_Options::get( 'noindex-' . $type ) === false
        || WPSEO_Options::get( 'noindex-tax-' . $type ) === false
    ) {
        self::invalidate( $type );
    }
}

The warning is triggered when $type is an array rather than a string.

In particular, these expressions implicitly convert $type to a string:

'noindex-' . $type

and

'noindex-tax-' . $type

which produces the PHP warning:

Array to string conversion
Hooks involved

invalidate_helper() is registered on the following WordPress hooks:

add_action( 'edited_terms', [ self::class, 'invalidate_helper' ], 10, 2 );
add_action( 'clean_term_cache', [ self::class, 'invalidate_helper' ], 10, 2 );
add_action( 'clean_object_term_cache', [ self::class, 'invalidate_helper' ], 10, 2 );

The problematic case appears to involve:

clean_object_term_cache

where the second argument ($object_type) can be an array of taxonomy names in some WordPress/WooCommerce execution paths.

invalidate_helper() currently assumes that $type is always a scalar string.

Doc: https://developer.wordpress.org/reference/functions/clean_object_term_cache/

Step-by-step reproduction instructions

The warning occurs during an automated process that updates WooCommerce products.

During the same request, several product taxonomies can be modified for the same product, including, the update pipeline performs operations equivalent to:

wp_set_object_terms( $product_id, ..., 'xxxxxx' );
wp_set_object_terms( $product_id, ..., 'yyyyyyyy' );
wp_set_object_terms( $product_id, ..., 'zzzzz' );

Additionally, WooCommerce product saving can modify the product_type taxonomy:

$product->save();

which can ultimately call:

wp_set_object_terms( $product_id, 'external', 'product_type' );

When these operations occur in the same execution flow, WordPress can reach clean_object_term_cache() with multiple taxonomies represented as an array.

Yoast SEO then receives that array as $type through:

invalidate_helper( $unused, $type )

and attempts:

'noindex-' . $type

resulting in:

Array to string conversion

Expected results

Yoast SEO should handle the value received from the WordPress hook safely.

If $type is an array containing multiple taxonomies, Yoast should either:

process each taxonomy individually, or
safely ignore unsupported/unexpected values.

In either case, updating or invalidating WooCommerce product term caches should not generate a PHP warning.

Actual behavior

When $type is an array, Yoast executes:

WPSEO_Options::get( 'noindex-' . $type )

which causes:

PHP Warning: Array to string conversion

The warning can occur repeatedly during automated product updates and creates noise in PHP/application logs.

Actual results

1. PHP Error [2] Array to string conversion

Screenshots, screen recording, code snippet

A robust implementation could explicitly handle arrays.

For example:

public static function invalidate_helper( $unused, $type ) {

    foreach ( (array) $type as $taxonomy ) {

        if (
            WPSEO_Options::get( 'noindex-' . $taxonomy ) === false
            || WPSEO_Options::get( 'noindex-tax-' . $taxonomy ) === false
        ) {
            self::invalidate( $taxonomy );
        }
    }
}

Alternatively, if Yoast expects this hook to always provide a single taxonomy, the method could explicitly validate the argument:

if ( ! is_string( $type ) ) {
    return;
}

However, iterating over the array would likely be preferable if WordPress can legitimately provide multiple taxonomy names, because it preserves the cache invalidation behavior for every taxonomy.

Why we believe this is a Yoast SEO compatibility/robustness issue

The application code is modifying several WooCommerce taxonomies, but it does not directly concatenate or otherwise convert taxonomy arrays to strings.

The warning is generated inside Yoast SEO because invalidate_helper() assumes that the $type parameter is always a string.

The method does not currently perform any type validation before using $type in string concatenation.

Therefore, the underlying trigger is the interaction between WordPress/WooCommerce taxonomy cache invalidation and Yoast's invalidate_helper() implementation.

Which editor is affected (or editors)

• Block Editor
• Gutenberg Editor
• Elementor Editor
• Classic Editor
• Other (please specify in additional info)

Which browser is affected (or browsers)

• Chrome
• Firefox
• Safari
• Other (please specify in additional info)

Device you are using

No response

Operating system

No response

PHP version

8.3

WordPress version

7.0.3

WordPress Theme

No response

Yoast SEO version

28.2

Gutenberg plugin version (if relevant)

No response

Elementor plugin version (if relevant)

No response

Classic Editor plugin version (if relevant)

No response

Relevant plugins in case of a bug

WooCommerce 11.0.1

[josevarghese]

Hi @gab12

Thanks for creating the issue. Could you please clearly document the steps to reproduce the issue? At the moment, you have only mentioned that an automated process updates WooCommerce products and generates PHP warning messages, but it is not clear what this process is or how it triggers the issue.

So kindly please share the exact steps, including details about the automated process and any relevant configuration. This will help us reproduce the issue and, if confirmed, we can escalate it to the appropriate team for further investigation. You can mention the steps in the following sample:

1. Install the Yoast SEO plugin and WooCommerce
2. Navigate to XYZ and perform this action

Looking forward.

[gab12]

Thank you for your response.

I understand your request for a precise reproduction scenario.

In our case, the issue occurs as part of an automated batch process that updates WooCommerce products. Several taxonomies can be modified successively while processing the same product, notably through wp_set_object_terms(), and then again during the product save process.

Because this process is fully automated, we unfortunately cannot provide a reliable manual procedure that would reproduce the issue consistently step by step.

However, we have been able to identify the exact cause of the warning, and I believe this is an important point when assessing the ticket.

Over only 3 days of logs, we recorded 851 occurrences of:

PHP Error [2] Array to string conversion in
wp-content/plugins/wordpress-seo/inc/sitemaps/class-sitemaps-cache.php on line 206
PHP Error [2] Array to string conversion in
wp-content/plugins/wordpress-seo/inc/sitemaps/class-sitemaps-cache.php on line 207

This is the only PHP error generated by this process.

The error originates from invalidate_helper() when $type is an array:

WPSEO_Options::get( 'noindex-' . $type )

The official WordPress documentation states that clean_object_term_cache() accepts array|string for $object_type, and this value is then passed unchanged to the hook.

WordPress documentation — clean_object_term_cache()

The issue in invalidate_helper() can therefore be identified without reproducing our specific environment: the callback receives a value originating from a WordPress API that accepts array|string, and then directly performs a string concatenation that is only valid for a string.

In other words, even without knowing the exact details of our automation, the following sequence is already sufficient to explain the warning:

WordPress
↓
clean_object_term_cache()
↓
$object_type = array(...)
↓
value passed to the hook unchanged
↓
Yoast invalidate_helper( ..., $type )
↓
'noindex-' . $type
↓
Array to string conversion

In my opinion, we therefore have a genuine implementation error in your plugin when handling a value provided by a WordPress API, independently of the specific WooCommerce workflow that triggers it in our environment.

The fix is also very limited:

public static function invalidate_helper( $unused, $type ) {

    foreach ( (array) $type as $taxonomy ) {

        if (
            WPSEO_Options::get( 'noindex-' . $taxonomy ) === false
            || WPSEO_Options::get( 'noindex-tax-' . $taxonomy ) === false
        ) {
            self::invalidate( $taxonomy );
        }
    }
}

This preserves exactly the current behavior when a string is received, while allowing multiple values to be handled correctly.

I therefore believe the information available is sufficient for this issue to be forwarded to your development team, even though we cannot provide a deterministic manual reproduction of our automated process.

We would of course be happy to test any proposed fix in our environment and confirm the result.

Thank you in advance for forwarding the ticket to your development team.

[josevarghese]

Note

Internal Slack conversation: https://yoast.slack.com/archives/C01NCRHHN30/p1787201825668269

[josevarghese]

Hi @gab12,

Thanks for the information. I have asked our development team to take a closer look at this issue. Our developers prioritize the highest-priority issues first. Unfortunately, this means we are unable to provide an estimated timeframe for when they will investigate this warning.

As soon as I receive more information or the development team has any further details, we'll keep you posted.

Thanks for your patience and understanding!