The way to construct customized WP-CLI instructions and automate WordPress repairs with Acorn

The $signature belongings makes use of a particular syntax:

• A fundamental command handiest wishes a reputation, akin to cleanup:run.
• You upload required arguments through wrapping them in curly braces (cleanup:run {days}, as an example).
• Not obligatory arguments get a query mark: cleanup:run {days?}.
• Choices use double dashes: cleanup:run {--force} {--limit=100}.

Subsequent, come with an outline for the command and your fundamental common sense:

safe $signature = 'cleanup:check {--dry-run : Preview adjustments with out executing}';
safe $description = 'Check cleanup command';
public serve as deal with()
{
    $dryRun = $this->possibility('dry-run');

    if ($dryRun) {
        $this->components->data('Operating in dry-run mode');
    }

    $this->components->data('Cleanup command performed');

    go back 0;
}

You'll check this the use of wp acorn cleanup:check --dry-run. The command outputs formatted messages the use of Artisan’s part gadget. The $this->components->data() way presentations luck messages in inexperienced. You'll additionally use $this->components->error() for mistakes, $this->components->warn() for warnings, and $this->line() for undeniable textual content output.

The way to construct 3 sensible repairs instructions

Listed below are some examples that allow you to take on database repairs duties that arise for a lot of WordPress web sites.

Whilst every command contains error dealing with and in large part follows WordPress coding requirements to stay your information secure, you must nonetheless use those as a skeleton on your personal tasks fairly than just copy-paste them.

1. Cleansing orphaned submit metadata

Publish metadata sticks round after you delete posts. This occurs when plugins bypass WordPress’s deletion hooks and depart metadata entries pointing to posts that not exist. Over the years, this bloat slows down your database queries.

If you create the command with wp acorn make:command CleanupOrphanedMeta, you'll get started with the command elegance construction and signature:

possibility('dry-run');

        $this->components->data('Scanning for orphaned submit metadata...');

The command makes use of a LEFT JOIN question to search out those orphaned data. The development assessments for NULL values within the posts desk. If the sign up for returns NULL the metadata belongs to a deleted submit:

        // To find orphaned metadata
        $orphans = $wpdb->get_results("
            SELECT pm.meta_id, pm.post_id, pm.meta_key 
            FROM {$wpdb->postmeta} pm
            LEFT JOIN {$wpdb->posts} p ON pm.post_id = p.ID
            WHERE p.ID IS NULL
            LIMIT 1000
        ");

        if (empty($orphans)) {
            $this->components->data('No orphaned metadata discovered');
            go back 0;
        }

When the command unearths orphans, it displays you a rely and samples a couple of data should you’re in dry-run mode. You want to make sure what’s getting deleted earlier than you devote:

        $rely = rely($orphans);
        $this->components->warn("Discovered {$rely} orphaned metadata data");
        if ($dryRun) {
            $this->newLine();
            $this->line('Pattern orphaned data:');

            foreach (array_slice($orphans, 0, 5) as $orphan) {
                $this->line("  → Publish ID {$orphan->post_id}: {$orphan->meta_key}");
            }

            go back 0;
        }

The real deletion makes use of $wpdb->get ready() to steer clear of SQL injection assaults. The command processes 1,000 data at a time, which prevents reminiscence issues on websites with tens of millions of metadata entries:

        // Delete orphaned data
        $metaIds = array_map(serve as($orphan) {
            go back $orphan->meta_id;
        }, $orphans);

        $placeholders = implode(',', array_fill(0, rely($metaIds), '%d'));

        $deleted = $wpdb->question(
            $wpdb->get ready(
                "DELETE FROM {$wpdb->postmeta} WHERE meta_id IN ({$placeholders})",
                ...$metaIds
            )
        );

        if ($deleted === false) {
            $this->components->error('Didn't delete orphaned metadata');
            go back 1;
        }

        $this->components->data("Deleted {$deleted} orphaned metadata data");
        go back 0;
    }
}

To run the command, use wp acorn repairs:cleanup-orphaned-meta --dry-run.

2. Deleting expired transients

WordPress retail outlets transients in wp_options with expiration dates. Whilst a day-to-day cron task cleans those up, you every now and then want to run a guide cleanup right through repairs home windows or when temporary bloat turns into an issue.

After you generate the command with wp acorn make:command CleanupTransients, you'll arrange the command construction:

components->data('Deleting expired transients...');

This deletion question makes use of multi-table DELETE syntax to take away each the temporary and its timeout possibility without delay. The question unearths timeout data the place the expiration timestamp has handed:

        // Delete expired common transients
        $deleted = $wpdb->question(
            $wpdb->get ready(
                "DELETE a, b FROM {$wpdb->choices} a, {$wpdb->choices} b
                WHERE a.option_name LIKE %s
                AND a.option_name NOT LIKE %s
                AND b.option_name = CONCAT('_transient_timeout_', SUBSTRING(a.option_name, 12))
                AND b.option_value < %d",
                $wpdb->esc_like('_transient_') . '%',
                $wpdb->esc_like('_transient_timeout_') . '%',
                time()
            )
        );

Additionally test for mistakes and observe the deletion rely:

        if ($deleted === false) {
            $this->components->error('Didn't delete transients');
            go back 1;
        }

        $transientCount = $deleted;

On Multisite installations, the command runs a 2d question for web page transients. Those use other desk prefixes however practice the similar deletion development:

        // Delete expired web page transients (multisite)
        if (is_multisite()) {
            $siteDeleted = $wpdb->question(
                $wpdb->get ready(
                    "DELETE a, b FROM {$wpdb->choices} a, {$wpdb->choices} b
                    WHERE a.option_name LIKE %s
                    AND a.option_name NOT LIKE %s
                    AND b.option_name = CONCAT('_site_transient_timeout_', SUBSTRING(a.option_name, 17))
                    AND b.option_value < %d",
                    $wpdb->esc_like('_site_transient_') . '%',
                    $wpdb->esc_like('_site_transient_timeout_') . '%',
                    time()
                )
            );

            if ($siteDeleted !== false) {
                $transientCount += $siteDeleted;
            }
        }

        $this->components->data("Deleted {$transientCount} expired transients");

        go back 0;
    }
}

To execute the command, run wp acorn repairs:cleanup-transients.

3. Auditing autoloaded choices

Autoloaded choices load on each request your WordPress web page handles. You'll begin to see slowdowns and reminiscence intake spikes when this information crosses 1MB. This command unearths your greatest autoloaded choices so you'll observe down which plugins purpose the bloat.

First, create the audit command with wp acorn make:command AuditAutoload. Then, outline the command signature with a configurable threshold:

possibility('threshold');

        $this->components->data('Calculating autoloaded choices dimension...');

From right here, calculate the full dimension of all autoloaded choices:

        // Get overall autoload dimension
        $consequence = $wpdb->get_row(
            "SELECT 
                SUM(LENGTH(option_value)) as total_bytes,
                COUNT(*) as total_count
            FROM {$wpdb->choices}
            WHERE autoload = 'sure'"
        );

        $totalBytes = (int) $result->total_bytes;
        $totalCount = (int) $result->total_count;
        $totalMb = spherical($totalBytes / 1024 / 1024, 2);

        $this->newLine();
        $this->line("Overall autoloaded: {$totalMb} MB ({$totalCount} choices)");

The command runs a question for choices above your threshold, varieties them through dimension, and boundaries effects to the largest 20:

        // Get greatest autoloaded choices
        $largeOptions = $wpdb->get_results(
            $wpdb->get ready(
                "SELECT option_name, LENGTH(option_value) as size_bytes
                FROM {$wpdb->choices}
                WHERE autoload = 'sure'
                AND LENGTH(option_value) > %d
                ORDER BY size_bytes DESC
                LIMIT 20",
                $threshold
            )
        );

        if (empty($largeOptions)) {
            $this->components->data('No choices exceed the brink');
            go back 0;
        }

Artisan’s $this->desk() way codecs those effects as an ASCII desk: studying tabular information to your terminal beats parsing the uncooked question output:

        $this->newLine();
        $this->components->warn('Massive autoloaded choices:');
        $this->newLine();

        $tableData = [];

        foreach ($largeOptions as $possibility) {
            $sizeKb = spherical($option->size_bytes / 1024, 2);
            $tableData[] = [
                $option->option_name,
                $sizeKb . ' KB'
            ];
        }

        $this->desk(
            ['Option Name', 'Size'],
            $tableData
        );

The command throws a caution when the full autoload crosses 3MB, which signifies a efficiency drawback you want to deal with:

        if ($totalBytes > 3000000) {
            $this->newLine();
            $this->components->error('Caution: Overall autoload exceeds 3MB');
        }

        go back 0;
    }
}

To run the audit, use wp acorn repairs:audit-autoload --threshold=500000.

The way to get admission to WordPress information inside instructions

WordPress purposes paintings inside of your command strategies as a result of Acorn boots inside WordPress’s lifecycle. This implies you'll name some purposes akin to get_posts() or get_option() with none particular setup:

public serve as deal with()
{
    $posts = get_posts([
        'post_type' => 'post',
        'post_status' => 'publish',
        'numberposts' => 10,
    ]);

    foreach ($posts as $submit) {
        $this->line($post->post_title);
    }

    go back 0;
}

For direct database queries, claim the $wpdb international at first of your way:

public serve as deal with()
{
    international $wpdb;   

    $rely = $wpdb->get_var(
        "SELECT COUNT(*) FROM {$wpdb->posts} WHERE post_status = 'put up'"
    );

    $this->line("Revealed posts: {$rely}");

    go back 0;
}

$wpdb->get ready() is perfect on every occasion your queries come with variables or consumer enter because it is helping to forestall SQL injection assaults:

$standing = 'put up';
$postType = 'submit';
$effects = $wpdb->get_results(
    $wpdb->get ready(
        "SELECT ID, post_title FROM {$wpdb->posts} 
        WHERE post_status = %s AND post_type = %s",
        $standing,
        $postType
    )
);

In case you check for false after any database operations, this must permit you to catch mistakes:

$up to date = $wpdb->replace(
    $wpdb->posts,
    ['post_status' => 'draft'],
    ['ID' => 123],
    ['%s'],
    ['%d']
);

if ($up to date === false) {
    $this->components->error('Database replace failed');
    go back 1;
}

Customized submit varieties and taxonomies paintings via usual WordPress purposes:

$phrases = get_terms([
    'taxonomy' => 'category',
    'hide_empty' => false,
]);

foreach ($phrases as $time period) {
    wp_update_term($term->term_id, 'class', [
        'description' => 'Updated via command',
    ]);
}

Customized WP-CLI instructions are easy with Acorn and Artisan Console

Acorn allows you to get admission to Laravel’s structured command categories, formatted output substances, correct error dealing with, and extra, whilst providing you with complete get admission to to WordPress’ purposes and information.

You'll combine instructions via SSH get admission to and cron scheduling inside Kinsta. You'll additionally upload instructions for your deployment scripts to automate repairs, for example the use of GitHub Movements workflows.

In case you’re in a position to centralize your WordPress repairs duties with customized WP-CLI instructions, Kinsta’s controlled WordPress webhosting contains SSH get admission to and WP-CLI on all plans.

The submit The way to construct customized WP-CLI instructions and automate WordPress repairs with Acorn gave the impression first on Kinsta®.

[ continue ]