justdev / jd-support

2.2.0 2026-09-16 15:30 UTC

Requires

• php: >=7.4

Requires (Dev)

• phpstan/phpstan: ^1.0
• phpunit/phpunit: ^9.0
• squizlabs/php_codesniffer: ^3.0

GPL-2.0+

• Kyrylo Dorozhynskyi

Published on Packagist.org on 2026-09-16 15:31 UTC

README

Overview

Version 2.2 adds the shared data-cache API and removes browser-cache rule generation. See project cache migration guide for the bidirectional theme adapter, fallback without the plugin, automatic invalidation, and legacy .htaccess cleanup.

This plugin has been completely redesigned using modern development principles and architectural patterns.

New Architecture

Project Structure

src/
├── Core/                    # Plugin core
│   ├── Plugin.php          # Main plugin class
│   ├── Container/          # Dependency Injection
│   │   └── Container.php
│   ├── Config/             # Configuration management
│   │   └── ConfigManager.php
│   └── Hooks/              # Hook management
│       └── HookManager.php
├── Services/               # Business logic
│   ├── SecurityService.php
│   ├── AdminService.php
│   ├── CacheService.php
│   ├── SvgService.php
│   └── VersionService.php
├── Admin/                  # Administrative part
│   ├── AdminManager.php
│   └── Controllers/
│       ├── SettingsController.php
│       └── AssetsController.php
├── Public/                 # Public part
│   ├── PublicManager.php
│   └── Controllers/
│       └── AssetsController.php
└── Views/                  # Views
    └── settings-page.php

Key Improvements

1. Dependency Injection Container

• Centralized dependency management
• Automatic service instance creation
• Easy testing and extensibility

2. Service Layer Pattern

• Separation of business logic into separate services
• Each service is responsible for specific functionality
• Easy code reuse

3. MVC Architecture

• Controllers for request handling
• Views for data display
• Models (services) for business logic

4. Configuration Management

• Centralized settings management
• Typed methods for configuration work
• Automatic settings validation

5. Hook Management

• Structured WordPress hook management
• Automatic registration of all hooks
• Easy addition of new hooks

Installation and Usage

Requirements

• PHP 7.4+
• WordPress 5.0+

Installation

Via Composer (recommended)

1. Add the repository (if private) and require the package:

   composer require justdev/jd-support:"^2.2"

2. Copy stubs/jd-support-mu-loader.php to wp-content/mu-plugins/jd-support.php (or symlink it) so WordPress loads the vendor package.
3. Run composer install (or composer update) to ensure the package lives in vendor/justdev/jd-support.
4. Configure options in the "j|D Support" section of the admin area.

Manual (legacy)

1. Copy this repository into wp-content/mu-plugins/jd-support/.
2. Ensure jd-support.php is present directly in that folder.
3. Configure options in the "j|D Support" section.

Development

Adding a new service

// 1. Create service in src/Services/
class NewService
{
    public function __construct(Container $container)
    {
        $this->config = $container->get('config');
    }
    
    public function doSomething()
    {
        // Your logic
    }
}

// 2. Register in Container.php
$this->register('new', NewService::class);

// 3. Use in HookManager.php
$this->addAction('hook_name', [$this->container->get('new'), 'doSomething']);

Adding a new controller

// 1. Create controller in src/Admin/Controllers/
class NewController
{
    public function registerHooks()
    {
        add_action('admin_menu', [$this, 'addMenuPage']);
    }
}

// 2. Add to AdminManager.php
$this->newController = new NewController($this->container);
$this->newController->registerHooks();

Testing

Running tests

composer test

Code checking

composer phpcs    # Code style check
composer phpstan  # Static analysis
composer fix      # Auto-fix style

Migration from old version

Main changes

1. File structure: Completely redesigned
2. Namespace: PSR-4 autoloading used
3. Dependency Injection: Dependency container implemented
4. Service Layer: Business logic separated into services
5. Configuration: Centralized settings management

Compatibility

• All existing settings are preserved
• Hook API remains compatible
• Functionality unchanged

Advantages of new architecture

1. Maintainability

• Clear separation of responsibilities
• Easy understanding of code structure
• Simple addition of new features

2. Testability

• Each component can be tested separately
• Dependency Injection simplifies mocking
• Automated tests

3. Extensibility

• Easy addition of new services
• Modular architecture
• Component reuse

4. Performance

• Loading only necessary classes
• Optimized dependency container
• Configuration caching

License

GPL-2.0+

Author

Kyrylo Dorozhynskyi | justDev