<?php
|
namespace JVBase\managers;
|
|
if (!defined('ABSPATH')) {
|
exit;
|
}
|
|
/**
|
* Manages HTTP cache timestamps and relationship-based invalidation
|
*
|
* Data caching: Use wrapper methods or wp_cache_get/set directly
|
* HTTP caching: This class manages timestamps for ETag/Last-Modified headers
|
*/
|
class CacheManager
|
{
|
private const CONNECTIONS_OPTION = BASE.'cache_connections';
|
private static ?array $connections_cache = null; // Cache in memory
|
private string $prefix = BASE;
|
private string $group;
|
private int $cache_ttl;
|
private static ?bool $use_object_cache = null;
|
private static array $instances = []; // Cache instances per type
|
private static array $http_timestamps = []; // Request-level memory cache
|
private static ?CacheManager $singleton = null;
|
|
/**
|
* Private constructor - use for() factory method instead
|
*/
|
private function __construct(string $group, ?int $ttl = null)
|
{
|
$this->group = jvbNoBase($group);
|
$this->cache_ttl = $ttl ?: 3600;
|
|
if (is_null(static::$use_object_cache)) {
|
static::$use_object_cache = wp_using_ext_object_cache();
|
}
|
|
add_action('init', [$this, 'registerHooks']);
|
}
|
|
/**
|
* Get singleton instance (for general cache operations)
|
* For type-specific operations, use for() or forUser() instead
|
*/
|
public static function getInstance(): self
|
{
|
if (self::$singleton === null) {
|
self::$singleton = new self('global', HOUR_IN_SECONDS);
|
}
|
return self::$singleton;
|
}
|
|
/**
|
* Get all cache connections (public accessor)
|
*
|
* @return array Array of cache group connections
|
*/
|
public static function getAllConnections(): array
|
{
|
return self::getConnections();
|
}
|
|
/**
|
* Get all registered cache groups
|
*
|
* @return array List of cache group names
|
*/
|
public static function getAllGroups(): array
|
{
|
$connections = self::getConnections();
|
return array_keys($connections);
|
}
|
/**
|
* Register WordPress hooks for automatic cache invalidation
|
* Call this once during plugin initialization
|
*/
|
public static function registerHooks(): void
|
{
|
// Post updates (all post types including core)
|
add_action('save_post', [self::class, 'onPostSave'], 10, 2);
|
add_action('delete_post', [self::class, 'onPostDelete']);
|
// Meta updates (will catch MetaManager updates)
|
add_action('updated_post_meta', [self::class, 'onPostMetaUpdate'], 10, 4);
|
add_action('added_post_meta', [self::class, 'onPostMetaUpdate'], 10, 4);
|
add_action('deleted_post_meta', [self::class, 'onPostMetaDelete'], 10, 4);
|
// transition_post_status?
|
|
// Term updates (all taxonomies)
|
add_action('edited_term', [self::class, 'onTermSave'], 10, 3);
|
add_action('create_term', [self::class, 'onTermSave'], 10, 3);
|
add_action('delete_term', [self::class, 'onTermDelete'], 10, 3);
|
|
// Term meta updates
|
add_action('updated_term_meta', [self::class, 'onTermMetaUpdate'], 10, 4);
|
add_action('added_term_meta', [self::class, 'onTermMetaUpdate'], 10, 4);
|
add_action('deleted_term_meta', [self::class, 'onTermMetaDelete'], 10, 4);
|
|
// User updates
|
add_action('profile_update', [self::class, 'onUserUpdate'], 10, 2);
|
add_action('user_register', [self::class, 'onUserUpdate'], 10, 1);
|
add_action('deleted_user', [self::class, 'onUserDelete']);
|
|
// User meta updates
|
add_action('updated_user_meta', [self::class, 'onUserMetaUpdate'], 10, 4);
|
add_action('added_user_meta', [self::class, 'onUserMetaUpdate'], 10, 4);
|
add_action('deleted_user_meta', [self::class, 'onUserMetaDelete'], 10, 4);
|
}
|
|
/**
|
* Get or create a cache manager instance for a content type
|
*
|
* @param string $type Content type (tattoo, style, etc.)
|
* @param int|null $ttl Optional TTL override
|
* @return self Fluent interface
|
*/
|
public static function for(string $type, ?int $ttl = null): self
|
{
|
$type = jvbNoBase($type);
|
$key = $type . ($ttl ? "_{$ttl}" : '');
|
|
if (!isset(self::$instances[$key])) {
|
self::$instances[$key] = new self($type, $ttl);
|
}
|
|
return self::$instances[$key];
|
}
|
|
/**
|
* Get cache manager for a specific user
|
* Each user gets their own cache group for complete isolation
|
*
|
* @param int $user_id User ID
|
* @param int|null $ttl Optional TTL
|
* @return self
|
*/
|
public static function forUser(int $user_id, ?int $ttl = null): self
|
{
|
return self::for("user_{$user_id}", $ttl);
|
}
|
|
/**
|
* Get HTTP cache timestamp for content type(s)
|
* Used for ETag and Last-Modified header generation
|
*
|
* @param string|array $types Single type or array of types
|
* @return int Latest timestamp (Unix time)
|
*/
|
public static function getTimestamp(string|array $types): int
|
{
|
// Multiple types - return latest
|
if (is_array($types)) {
|
$latest = 0;
|
foreach ($types as $type) {
|
$timestamp = self::getTimestamp($type);
|
if ($timestamp > $latest) {
|
$latest = $timestamp;
|
}
|
}
|
return $latest ?: time();
|
}
|
|
$type = jvbNoBase($types);
|
|
// Check request-level cache
|
if (isset(self::$http_timestamps[$type])) {
|
return self::$http_timestamps[$type];
|
}
|
|
// Load from cache (Redis or transient - wp_cache handles it)
|
$timestamp = (int)wp_cache_get("http_ts_{$type}", 'jvb_timestamps') ?: time();
|
|
// Cache in memory for this request
|
self::$http_timestamps[$type] = $timestamp;
|
|
return $timestamp;
|
}
|
|
/**
|
* Update HTTP cache timestamp (marks content as modified)
|
*
|
* @param string $type Content type
|
* @return int The new timestamp
|
*/
|
public static function updateTimestamp(string $type): int
|
{
|
$type = jvbNoBase($type);
|
$timestamp = time();
|
|
// Store (Redis or transient - wp_cache handles it)
|
wp_cache_set("http_ts_{$type}", $timestamp, 'jvb_timestamps', WEEK_IN_SECONDS);
|
|
// Update request cache
|
self::$http_timestamps[$type] = $timestamp;
|
|
do_action('jvb_http_timestamp_updated', $type, $timestamp);
|
|
return $timestamp;
|
}
|
|
/**
|
* Invalidate cache for a content type
|
*
|
* @param string $type Content type to invalidate
|
* @param string|array|null $specific_keys Optional specific key(s) to delete without flushing group
|
* @param bool $flush_connections Whether to flush connected caches
|
* @return void
|
*/
|
public static function invalidateAll(string $type, $specific_keys = null, bool $flush_connections = true): void
|
{
|
$type = jvbNoBase($type);
|
|
// Update HTTP timestamp
|
self::updateTimestamp($type);
|
|
// If specific keys provided, only delete those
|
if ($specific_keys !== null) {
|
$instance = self::for($type);
|
if (is_array($specific_keys)) {
|
foreach ($specific_keys as $key) {
|
$instance->delete($key);
|
}
|
} else {
|
$instance->delete($specific_keys);
|
}
|
} else {
|
// Flush the entire group
|
if (function_exists('wp_cache_flush_group')) {
|
wp_cache_flush_group($type);
|
} else {
|
wp_cache_flush();
|
}
|
}
|
|
// Flush connected caches
|
if ($flush_connections) {
|
self::for($type)->connections();
|
}
|
|
do_action('jvb_cache_invalidated', $type);
|
}
|
|
/**
|
* Invalidate only specific keys for a type (doesn't flush group or update timestamp)
|
* Use this when you want surgical cache invalidation
|
*
|
* @param string $type Content type
|
* @param string|array $keys Key(s) to delete
|
* @return void
|
*/
|
public static function invalidateKeys(string $type, string|array $keys): void
|
{
|
$instance = self::for($type);
|
|
if (is_array($keys)) {
|
foreach ($keys as $key) {
|
$instance->delete($key);
|
}
|
} else {
|
$instance->delete($keys);
|
}
|
}
|
|
/**
|
* Fluent instance method to invalidate this cache type
|
*
|
* @param string|array|null $specific_keys Optional specific key(s)
|
* @param bool $flush_connections Whether to flush connected caches
|
* @return self For chaining
|
*/
|
public function invalidate($specific_keys = null, bool $flush_connections = true): self
|
{
|
self::invalidateAll($this->group, $specific_keys, $flush_connections);
|
return $this;
|
}
|
|
/**
|
* Get the HTTP timestamp for this instance's type
|
*
|
* @return int
|
*/
|
public function timestamp(): int
|
{
|
return self::getTimestamp($this->group);
|
}
|
|
/**
|
* Update the HTTP timestamp for this instance's type
|
*
|
* @return self For chaining
|
*/
|
public function touch(): self
|
{
|
self::updateTimestamp($this->group);
|
return $this;
|
}
|
|
/**
|
* Get a value from the cache
|
* @param string|array $key The key to look up (auto-generates key from array of key=>values)
|
* @param string|null $group The group to get from. Defaults to current group
|
* @return mixed
|
*/
|
public function get(string|array $key, ?string $group = null): mixed
|
{
|
$group = $group ?: $this->group;
|
$key = $this->normalizeKey($key);
|
$cache_key = $this->buildKey($key);
|
|
$value = wp_cache_get($cache_key, $group);
|
|
// Fallback to transient if no external object cache
|
if ($value === false && !wp_using_ext_object_cache()) {
|
$value = get_transient($group . '_' . $cache_key);
|
}
|
|
return $value;
|
}
|
|
/**
|
* Store a value in cache
|
* @param string|array $key The key to look up (auto-generates key from array of key=>values)
|
* @param mixed $value The Value to set
|
* @param int|null $ttl The ttl (defaults to current set ttl)
|
* @param string|null $group The group to add cache to (defaults to current group))
|
* @return bool
|
*/
|
public function set(string|array $key, mixed $value, ?int $ttl = null, ?string $group = null): bool
|
{
|
$ttl = $ttl ?: $this->cache_ttl;
|
$group = $group ?: $this->group;
|
$key = $this->normalizeKey($key);
|
$cache_key = $this->buildKey($key);
|
|
self::updateTimestamp($this->group);
|
|
// Try object cache first
|
$result = wp_cache_set($cache_key, $value, $group, $ttl);
|
|
// If no external object cache, also store in transient for persistence
|
if (!wp_using_ext_object_cache()) {
|
set_transient($group . '_' . $cache_key, $value, $ttl);
|
}
|
|
return $result;
|
}
|
/**
|
* Delete a cached value
|
* @param string|array $key The key to look up (auto-generates key from array of key=>values)
|
* @param string|null $group The group to delete from (defaults to current group)
|
* @return bool
|
*/
|
public function delete(string|array $key, ?string $group = null): bool
|
{
|
$group = $group ?: $this->group;
|
$key = $this->normalizeKey($key);
|
$cache_key = $this->buildKey($key);
|
|
$result = wp_cache_delete($cache_key, $group);
|
|
// Also delete transient if no external object cache
|
if (!wp_using_ext_object_cache()) {
|
delete_transient($group . '_' . $cache_key);
|
}
|
|
return $result;
|
}
|
|
|
/**
|
* Clear all cache for this group
|
* @return bool
|
*/
|
public function clear(): bool
|
{
|
try {
|
if (function_exists('wp_cache_flush_group')) {
|
wp_cache_flush_group($this->group);
|
}
|
|
// Clear transients for this group if no external object cache
|
if (!wp_using_ext_object_cache()) {
|
$this->clearGroupTransients();
|
}
|
|
self::updateTimestamp($this->group);
|
return true;
|
} catch (\Exception $e) {
|
return false;
|
}
|
}
|
|
/**
|
* Clear all transients for this cache group
|
*/
|
private function clearGroupTransients(): void
|
{
|
global $wpdb;
|
|
$pattern = '_transient_' . $this->group . '_' . $this->prefix . '%';
|
$timeout_pattern = '_transient_timeout_' . $this->group . '_' . $this->prefix . '%';
|
|
$wpdb->query(
|
$wpdb->prepare(
|
"DELETE FROM $wpdb->options WHERE option_name LIKE %s OR option_name LIKE %s",
|
$pattern,
|
$timeout_pattern
|
)
|
);
|
}
|
|
/**
|
* Helper to generateKey from array if applicable
|
* @param string|array $key
|
* @return string
|
*/
|
private function normalizeKey(string|array $key): string
|
{
|
return is_array($key) ? $this->generateKey($key) : $key;
|
}
|
|
/**
|
* Generate a cache key from parameters
|
* @param array $params An array of key/values that differentiates this cache item from others
|
* @return string
|
*/
|
public function generateKey(array $params): string
|
{
|
// Sort params for consistent key generation
|
ksort($params);
|
return md5(serialize($params));
|
}
|
|
/**
|
* The workhorse shorthand of CacheManager. Tests the cache, and calls the callback if nothing is found.
|
* @param string|array $key The key to look up (auto-generates key from array of key=>values)
|
* @param callable $callback The callback to generate the value for this key
|
* @param int|null $ttl The time-to-live for the cache. Defaults to constructor
|
* @param string|null $group The group to save cache to. Defaults to constructor
|
* @return mixed
|
*/
|
public function remember(string|array $key, callable $callback, ?int $ttl = null, ?string $group = null): mixed
|
{
|
$group = $group ?: $this->group;
|
$ttl = $ttl ?: $this->cache_ttl;
|
$key = $this->normalizeKey($key);
|
|
$value = $this->get($key, $group);
|
|
if ($value === false) {
|
$value = $callback();
|
if ($value !== false && $value !== null) {
|
$this->set($key, $value, $ttl, $group);
|
}
|
}
|
|
return $value;
|
}
|
|
/**
|
* Build the cache key
|
* @param string $key
|
* @return string
|
*/
|
private function buildKey(string $key): string
|
{
|
return $this->prefix . $key;
|
}
|
|
/**
|
* Get instance group name (for debugging)
|
*/
|
public function getGroup(): string
|
{
|
return $this->group;
|
}
|
|
|
/***************************************************************************
|
* CONNECTIONS
|
* Connect to other caches by instantiating and defining connection
|
* Ex: CacheManager::for('usernames')->connectTo($type, $scope = 'all', $keyPattern)
|
* Where: $type = content / taxonomy / user
|
* $scope = either 'id' for specific item, or the entire group (registered post type, taxonomy, or user role)
|
* $keyPattern = ??
|
***************************************************************************/
|
/**
|
* Define a connection between cache groups
|
* Connected caches will have their ID-based keys deleted when this cache invalidates
|
*
|
* @param string $type Grand overview ('post', 'taxonomy', 'user')
|
* @param string $scope Type-specific constant, user role, or 'id'
|
* @return self For chaining
|
*/
|
public function connectTo(string $type, string $scope = 'id'): self
|
{
|
//TODO: Handle connect to where $type === 'all'
|
$connections = self::getConnections();
|
|
if (!isset($connections[$this->group])) {
|
$connections[$this->group] = [];
|
}
|
|
$new_connection = [
|
'parent' => $type,
|
'scope' => $scope
|
];
|
|
// Check if already exists
|
foreach ($connections[$this->group] as $existing) {
|
if ($existing === $new_connection) {
|
return $this;
|
}
|
}
|
|
$connections[$this->group][] = $new_connection;
|
update_option(self::CONNECTIONS_OPTION, $connections, false);
|
self::$connections_cache = $connections;
|
|
return $this;
|
}
|
|
/**
|
* Get all registered connections (cached for performance)
|
*
|
* @param bool $refresh Force refresh from database
|
* @return array
|
*/
|
private static function getConnections(bool $refresh = false): array
|
{
|
if (self::$connections_cache === null || $refresh) {
|
self::$connections_cache = get_option(self::CONNECTIONS_OPTION, []);
|
}
|
|
return self::$connections_cache;
|
}
|
|
/**
|
* Flush all caches connected to this one
|
*
|
* @return self For chaining
|
*/
|
public function connections(): self
|
{
|
$all_connections = self::getConnections();
|
|
foreach ($all_connections as $cache_group => $connections) {
|
foreach ($connections as $conn) {
|
if ($this->matchesConnection($conn)) {
|
$this->flushConnection($cache_group, $conn);
|
}
|
}
|
}
|
|
return $this;
|
}
|
|
/**
|
* Check if this cache group matches a connection definition
|
*/
|
private function matchesConnection(array $connection): bool
|
{
|
$parent = $connection['parent'] ?? '';
|
$scope = $connection['scope'] ?? 'id';
|
|
// Grand overview match
|
if ($this->group === $parent) {
|
return true;
|
}
|
|
// Type-specific match
|
if ($scope !== 'id') {
|
if ($this->group === jvbNoBase($scope)) {
|
return true;
|
}
|
|
// Check constants
|
if ($parent === 'post' && defined('JVB_CONTENT')) {
|
return isset(JVB_CONTENT[$scope]) && jvbNoBase($scope) === $this->group;
|
}
|
|
if ($parent === 'taxonomy' && defined('JVB_TAXONOMY')) {
|
return isset(JVB_TAXONOMY[$scope]) && jvbNoBase($scope) === $this->group;
|
}
|
}
|
|
// ID-specific match: 'user_123' matches 'user' + 'id'
|
if ($scope === 'id' && str_starts_with($this->group, $parent . '_')) {
|
return true;
|
}
|
|
return false;
|
}
|
|
/**
|
* Flush a connected cache group
|
* For ID-specific connections, deletes the specific ID key
|
* For type/overview connections, flushes entire group
|
*/
|
private function flushConnection(string $cache_group, array $connection): void
|
{
|
$scope = $connection['scope'] ?? 'id';
|
|
// ID-specific: delete specific key
|
if ($scope === 'id') {
|
$id = $this->extractIdFromGroup();
|
|
if ($id !== null) {
|
self::invalidateKeys($cache_group, $id);
|
return;
|
}
|
}
|
|
// Type/overview: flush entire group
|
self::invalidateAll($cache_group, specific_keys: null, flush_connections: false);
|
}
|
|
/**
|
* Extract ID from group name like 'user_123' -> '123'
|
*
|
* @return string|null
|
*/
|
private function extractIdFromGroup(): ?string
|
{
|
if (preg_match('/^[a-z]+_(\d+)$/', $this->group, $matches)) {
|
return $matches[1];
|
}
|
|
return null;
|
}
|
|
/**
|
* Register multiple connections at once
|
*/
|
public static function registerConnections(array $connections): void
|
{
|
$existing = self::getConnections();
|
$changed = false;
|
|
foreach ($connections as $cache_group => $configs) {
|
if (!isset($existing[$cache_group])) {
|
$existing[$cache_group] = [];
|
}
|
|
foreach ($configs as $config) {
|
$duplicate = false;
|
foreach ($existing[$cache_group] as $existing_config) {
|
if ($existing_config === $config) {
|
$duplicate = true;
|
break;
|
}
|
}
|
|
if (!$duplicate) {
|
$existing[$cache_group][] = $config;
|
$changed = true;
|
}
|
}
|
}
|
|
if ($changed) {
|
update_option(self::CONNECTIONS_OPTION, $existing, false);
|
self::$connections_cache = $existing;
|
}
|
}
|
|
/**
|
* Handle post save/update
|
*/
|
public static function onPostSave(int $post_id, \WP_Post $post): void
|
{
|
// Skip revisions and autosaves
|
if (wp_is_post_revision($post_id) || wp_is_post_autosave($post_id)) {
|
return;
|
}
|
|
$post_type = jvbNoBase($post->post_type);
|
|
// Invalidate post type cache
|
self::invalidateAll($post_type);
|
|
// Invalidate specific post cache
|
self::invalidateAll($post_id);
|
// Clear WordPress core post object cache
|
clean_post_cache($post_id);
|
}
|
|
/**
|
* Handle post deletion
|
*/
|
public static function onPostDelete(int $post_id): void
|
{
|
$post = get_post($post_id);
|
if (!$post) {
|
return;
|
}
|
|
$post_type = jvbNoBase($post->post_type);
|
|
self::invalidateAll($post_type);
|
self::invalidateAll($post_id);
|
// Clear WordPress core post object cache
|
clean_post_cache($post_id);
|
}
|
|
/**
|
* Handle term save/update
|
*/
|
public static function onTermSave(int $term_id, int $tt_id, string $taxonomy): void
|
{
|
// Clear WordPress core term cache
|
clean_term_cache($term_id, $taxonomy);
|
$taxonomy = jvbNoBase($taxonomy);
|
|
// Invalidate taxonomy cache
|
self::invalidateAll($taxonomy);
|
|
// Invalidate specific term cache
|
self::invalidateAll($term_id);
|
}
|
|
/**
|
* Handle term deletion
|
*/
|
public static function onTermDelete(int $term_id, int $tt_id, string $taxonomy): void
|
{
|
// Clear WordPress core term cache
|
clean_term_cache($term_id, $taxonomy);
|
$taxonomy = jvbNoBase($taxonomy);
|
|
self::invalidateAll($taxonomy);
|
self::invalidateAll($term_id);
|
}
|
|
/**
|
* Handle user update
|
*/
|
public static function onUserUpdate(int $user_id, ?\WP_User $old_user_data = null): void
|
{
|
// Invalidate user-specific cache
|
self::invalidateAll($user_id);
|
|
// Invalidate user role caches if roles changed
|
if ($old_user_data) {
|
$user = get_userdata($user_id);
|
if ($user && $user->roles !== $old_user_data->roles) {
|
foreach (array_merge($user->roles, $old_user_data->roles) as $role) {
|
self::invalidateAll($role);
|
}
|
}
|
}
|
// Clear WordPress core user cache
|
clean_user_cache($user_id);
|
}
|
|
/**
|
* Handle user deletion
|
*/
|
public static function onUserDelete(int $user_id): void
|
{
|
self::invalidateAll($user_id);
|
// Clear WordPress core user cache
|
clean_user_cache($user_id);
|
}
|
|
/**
|
* Handle post meta updates
|
*/
|
public static function onPostMetaUpdate(int $meta_id, int $post_id, string $meta_key, mixed $meta_value): void
|
{
|
if (!str_starts_with($meta_key, BASE)) {
|
return;
|
}
|
|
$post = get_post($post_id);
|
if (!$post) {
|
return;
|
}
|
|
self::onPostSave($post_id, $post);
|
}
|
public static function onPostMetaDelete(array $meta_ids, int $post_id, string $meta_key, mixed $meta_value):void
|
{
|
if (!str_starts_with($meta_key, BASE)) {
|
return;
|
}
|
|
$post = get_post($post_id);
|
if (!$post) {
|
return;
|
}
|
|
self::onPostSave($post_id, $post);
|
}
|
|
/**
|
* Handle term meta updates
|
*/
|
public static function onTermMetaUpdate(int $meta_id, int $term_id, string $meta_key, mixed $meta_value): void
|
{
|
if (!str_starts_with($meta_key, BASE)) {
|
return;
|
}
|
|
$term = get_term($term_id);
|
if (!$term || is_wp_error($term)) {
|
return;
|
}
|
|
self::onTermSave($term_id, $term->term_taxonomy_id, $term->taxonomy);
|
}
|
|
public static function onTermMetaDelete(array $meta_ids, int $term_id, string $meta_key, mixed $meta_value):void
|
{
|
if (!str_starts_with($meta_key, BASE)) {
|
return;
|
}
|
|
$term = get_term($term_id);
|
if (!$term || is_wp_error($term)) {
|
return;
|
}
|
|
self::onTermSave($term_id, $term->term_taxonomy_id, $term->taxonomy);
|
}
|
|
/**
|
* Handle user meta updates
|
*/
|
public static function onUserMetaUpdate(int $meta_id, int $user_id, string $meta_key, mixed $meta_value): void
|
{
|
if (!str_starts_with($meta_key, BASE)) {
|
return;
|
}
|
|
$user = get_userdata($user_id);
|
if (!$user) {
|
return;
|
}
|
|
self::onUserUpdate($user_id, null);
|
}
|
|
public static function onUserMetaDelete(array $meta_ids, int $user_id, string $meta_key, mixed $meta_value):void
|
{
|
if (!str_starts_with($meta_key, BASE)) {
|
return;
|
}
|
|
$user = get_userdata($user_id);
|
if (!$user) {
|
return;
|
}
|
|
self::onUserUpdate($user_id, null);
|
}
|
}
|
