<?php
|
namespace JVBase\managers;
|
|
if (!defined('ABSPATH')) {
|
exit;
|
}
|
|
class Cache
|
{
|
private string $group;
|
private int $ttl;
|
private static array $timestamps = [];
|
private const TS_GROUP = 'jvb_http_ts';
|
|
private const CONNECTIONS_OPTION = 'jvb_cache_connections';
|
private static ?array $connections = null;
|
protected array $tags = [];
|
|
private static array $instances = [];
|
private bool $hasRedis;
|
|
private function __construct(string $group, int $ttl)
|
{
|
$this->group = $group;
|
$this->ttl = $ttl;
|
$this->hasRedis = (bool) wp_using_ext_object_cache();
|
}
|
|
public static function registerHooks(): void
|
{
|
// Post updates (all post types including core)
|
add_action('save_post', [self::class, 'onPostChange'], 10, 2);
|
add_action('delete_post', [self::class, 'onPostDelete']);
|
|
// Post meta updates
|
add_action('updated_post_meta', [self::class, 'onPostMetaChange'], 10, 2);
|
add_action('added_post_meta', [self::class, 'onPostMetaChange'], 10, 2);
|
add_action('deleted_post_meta', [self::class, 'onPostMetaDelete'], 10, 2);
|
|
// Term updates (all taxonomies)
|
add_action('edited_term', [self::class, 'onTermChange'], 10, 3);
|
add_action('create_term', [self::class, 'onTermChange'], 10, 3);
|
add_action('delete_term', [self::class, 'onTermDelete'], 10, 3);
|
|
// Term meta updates
|
add_action('updated_term_meta', [self::class, 'onTermMetaChange'], 10, 2);
|
add_action('added_term_meta', [self::class, 'onTermMetaChange'], 10, 2);
|
add_action('deleted_term_meta', [self::class, 'onTermMetaDelete'], 10, 2);
|
|
// User updates
|
add_action('profile_update', [self::class, 'onUserChange'], 10, 2);
|
add_action('user_register', [self::class, 'onUserChange'], 10, 1);
|
add_action('deleted_user', [self::class, 'onUserDelete']);
|
|
// User meta updates
|
add_action('updated_user_meta', [self::class, 'onUserMetaChange'], 10, 2);
|
add_action('added_user_meta', [self::class, 'onUserMetaChange'], 10, 2);
|
add_action('deleted_user_meta', [self::class, 'onUserMetaDelete'], 10, 2);
|
}
|
|
/* ---------------------------------------------------------------------
|
* Factory
|
* ------------------------------------------------------------------- */
|
|
public static function for(string $group, int $ttl = HOUR_IN_SECONDS): self
|
{
|
$group = sanitize_key($group);
|
|
if (!isset(self::$instances[$group])) {
|
self::$instances[$group] = new self($group, $ttl);
|
}
|
|
return self::$instances[$group];
|
}
|
|
/* ---------------------------------------------------------------------
|
* Core operations
|
* ------------------------------------------------------------------- */
|
|
public function remember(int|string|array $key, callable $callback, ?int $ttl = null): mixed
|
{
|
if (is_array($key)) {
|
$key = $this->generateKey($key);
|
}
|
if (!empty($this->tags)) {
|
return $this->rememberTagged(
|
$key,
|
$this->tags,
|
$callback,
|
$ttl
|
);
|
}
|
|
$value = $this->get($key);
|
|
if ($value !== false) {
|
return $value;
|
}
|
|
$value = $callback();
|
|
if ($value !== null && $value !== false) {
|
$this->set($key, $value);
|
}
|
|
return $value;
|
}
|
|
public function get(int|string|array $id): mixed
|
{
|
if (is_array($id)) {
|
$id = $this->generateKey($id);
|
}
|
if ($this->hasRedis) {
|
$value = wp_cache_get($id, $this->group);
|
} else {
|
$value = get_transient("jvb_{$this->group}_{$id}");
|
}
|
|
return $value;
|
}
|
|
public function set(int|string|array $id, mixed $value, ?int $ttl = null): void
|
{
|
if (is_array($id)) {
|
$id = $this->generateKey($id);
|
}
|
$ttl = $ttl ?? $this->ttl;
|
if ($this->hasRedis) {
|
wp_cache_set($id, $value, $this->group, $ttl);
|
} else {
|
set_transient("jvb_{$this->group}_{$id}", $value, $ttl);
|
}
|
}
|
|
public function forget(int|string|array $id): void
|
{
|
if (is_array($id)) {
|
$id = $this->generateKey($id);
|
}
|
if ($this->hasRedis) {
|
wp_cache_delete($id, $this->group);
|
} else {
|
delete_transient("jvb_{$this->group}_{$id}");
|
}
|
}
|
|
public function flush(): void
|
{
|
if ($this->hasRedis) {
|
if (function_exists('wp_cache_flush_group')) {
|
wp_cache_flush_group($this->group);
|
} else {
|
wp_cache_flush();
|
}
|
} else {
|
$this->clearGroupTransients();
|
}
|
}
|
|
/* ---------------------------------------------------------------------
|
* Invalidation
|
* ------------------------------------------------------------------- */
|
|
public static function invalidateItem(string $group, int|string|array $id): void
|
{
|
if (is_array($id)) {
|
$id = self::for($group)->generateKey($id);
|
}
|
$group = sanitize_key($group);
|
|
if (wp_using_ext_object_cache()) {
|
wp_cache_delete($id, $group);
|
} else {
|
delete_transient("jvb_{$group}_{$id}");
|
}
|
self::touch($group);
|
|
foreach (self::connections()[$group] ?? [] as $conn) {
|
$target = $conn['target'] ?? $conn; // Backwards compat if still string
|
$flush = $conn['flush'] ?? false;
|
|
if ($flush) {
|
// Flush entire target group
|
self::invalidateGroup($target);
|
} else {
|
// Just delete this item ID
|
if (wp_using_ext_object_cache()) {
|
wp_cache_delete($id, $target);
|
} else {
|
delete_transient("jvb_{$target}_{$id}");
|
}
|
self::touch($target);
|
}
|
}
|
self::invalidateByTag($group, $id);
|
}
|
|
public static function invalidateGroup(string $group): void
|
{
|
$group = sanitize_key($group);
|
|
if (wp_using_ext_object_cache()) {
|
wp_cache_flush_group($group);
|
} else {
|
$instance = self::for($group);
|
$instance->clearGroupTransients();
|
}
|
|
self::touch($group);
|
|
foreach (self::connections()[$group] ?? [] as $conn) {
|
$target = $conn['target'] ?? $conn; // Backwards compat
|
|
// When flushing entire source group, always flush connected targets
|
// (regardless of flush flag - we don't know which items to delete)
|
if (wp_using_ext_object_cache()) {
|
wp_cache_flush_group($target);
|
} else {
|
$instance = self::for($target);
|
$instance->clearGroupTransients();
|
}
|
self::touch($target);
|
}
|
}
|
|
public static function touch(string $group): int
|
{
|
$group = sanitize_key($group);
|
$time = time();
|
|
if (wp_using_ext_object_cache()) {
|
wp_cache_set($group, $time, self::TS_GROUP, WEEK_IN_SECONDS);
|
} else {
|
set_transient('jvb_ts_' . $group, $time, WEEK_IN_SECONDS);
|
}
|
|
self::$timestamps[$group] = $time;
|
return $time;
|
}
|
|
public static function lastModified(string|array $groups): int
|
{
|
if (is_array($groups)) {
|
return max(array_map([self::class, 'lastModified'], $groups));
|
}
|
|
$group = sanitize_key($groups);
|
|
if (isset(self::$timestamps[$group])) {
|
return self::$timestamps[$group];
|
}
|
|
if (wp_using_ext_object_cache()) {
|
$ts = (int) wp_cache_get($group, self::TS_GROUP);
|
} else {
|
$ts = (int) get_transient('jvb_ts_' . $group);
|
}
|
|
if (!$ts) {
|
$ts = time();
|
if (wp_using_ext_object_cache()) {
|
wp_cache_set($group, $ts, self::TS_GROUP, WEEK_IN_SECONDS);
|
} else {
|
set_transient('jvb_ts_' . $group, $ts, WEEK_IN_SECONDS);
|
}
|
}
|
|
return self::$timestamps[$group] = $ts;
|
}
|
|
public function getLastModifiedForTags(array $tags): ?int
|
{
|
if (!$this->hasRedis) {
|
return null;
|
}
|
$redis = self::redis();
|
if (!$redis) {
|
return null;
|
}
|
|
$lastModified = 0;
|
|
foreach ($tags as $tag) {
|
$ts = $redis->get("jvb:tag:{$tag}:lastModified");
|
if ($ts) {
|
$lastModified = max($lastModified, (int) $ts);
|
}
|
}
|
|
return $lastModified ?: null;
|
}
|
|
/****************************************************
|
* CONNECTIONS
|
****************************************************/
|
private static function connections(): array
|
{
|
if (self::$connections === null) {
|
self::$connections = get_option(self::CONNECTIONS_OPTION, []);
|
}
|
return self::$connections;
|
}
|
|
|
public function connect(string $source, bool $flush = false): self
|
{
|
$source = sanitize_key($source);
|
$target = $this->group;
|
|
$all = self::connections();
|
$all[$source] ??= [];
|
|
$before = count($all[$source]);
|
|
// Add the connection
|
$all[$source][] = ['target' => $target, 'flush' => $flush];
|
|
// Remove duplicates by serializing for comparison
|
$all[$source] = array_values(array_unique($all[$source], SORT_REGULAR));
|
|
// Only update if something actually changed
|
if (count($all[$source]) !== $before) {
|
update_option(self::CONNECTIONS_OPTION, $all, false);
|
self::$connections = $all;
|
}
|
|
return $this;
|
}
|
/****************************************************
|
* REDIS
|
****************************************************/
|
private static function redis(): ?\Redis
|
{
|
global $wp_object_cache;
|
|
return $wp_object_cache instanceof \WP_Object_Cache
|
&& isset($wp_object_cache->redis)
|
? $wp_object_cache->redis
|
: null;
|
}
|
|
/**
|
* Remember with tags for complex invalidation scenarios
|
*
|
* Example: Cache user favorites tagged by each post ID
|
* When any post updates, this cache entry auto-invalidates
|
*
|
* @param int|string|array $key Cache key
|
* @param array $tags Array of [group, id] pairs: [['post', 123], ['user', 456]]
|
* @param callable $callback Function to generate value if cache miss
|
* @return mixed Cached or generated value
|
*/
|
public function rememberTagged(
|
int|string|array $key,
|
array $tags,
|
callable $callback,
|
?int $ttl = null
|
): mixed {
|
if (is_array($key)) {
|
$id = $this->generateKey($key);
|
}
|
$tags = array_unique(array_merge(
|
$this->getTags(),
|
array_map('sanitize_key', $tags)
|
));
|
|
|
$value = wp_cache_get($key, $this->group);
|
if ($value !== false) {
|
return $value;
|
}
|
|
$value = $callback();
|
if ($value === null || $value === false) {
|
return $value;
|
}
|
|
wp_cache_set($key, $value, $this->group, $this->ttl);
|
|
if ($redis = self::redis()) {
|
foreach ($tags as [$tagGroup, $tagId]) {
|
$redis->sAdd("tag:$tagGroup:$tagId", "{$this->group}:$key");
|
}
|
}
|
|
return $value;
|
}
|
|
private static function invalidateByTag(string $group, int|string|array $id): void
|
{
|
if (is_array($id)) {
|
$id = self::for($group)->generateKey($id);
|
}
|
if (!$redis = self::redis()) {
|
return;
|
}
|
|
$key = "tag:$group:$id";
|
$targets = $redis->sMembers($key);
|
|
foreach ($targets as $target) {
|
[$group, $id] = explode(':', $target, 2);
|
wp_cache_delete($id, $group);
|
}
|
|
$redis->del($key);
|
}
|
|
public function tag(string $tag): static
|
{
|
$this->tags[] = sanitize_key($tag);
|
return $this;
|
}
|
|
public function getTags(): array
|
{
|
return array_unique($this->tags);
|
}
|
/****************************************************
|
* TRANSIENT HELPER
|
****************************************************/
|
private function clearGroupTransients(): void
|
{
|
global $wpdb;
|
|
$pattern = '_transient_jvb_' . $this->group . '_%';
|
$timeout_pattern = '_transient_timeout_jvb_' . $this->group . '_%';
|
|
// Remove LIMIT to avoid table locks, add retry for deadlocks
|
$attempts = 0;
|
$max_attempts = 3;
|
|
while ($attempts < $max_attempts) {
|
$result = $wpdb->query(
|
$wpdb->prepare(
|
"DELETE FROM $wpdb->options
|
WHERE option_name LIKE %s OR option_name LIKE %s",
|
$pattern,
|
$timeout_pattern
|
)
|
);
|
|
// Success or non-deadlock error
|
if ($result !== false || !str_contains($wpdb->last_error, 'Deadlock')) {
|
break;
|
}
|
|
$attempts++;
|
if ($attempts < $max_attempts) {
|
usleep(50000); // Wait 50ms before retry
|
}
|
}
|
}
|
/****************************************************
|
* HOOKS
|
****************************************************/
|
/****************************************************
|
* HOOKS - Posts
|
****************************************************/
|
public static function onPostChange(int $postId, \WP_Post $post): void
|
{
|
if (wp_is_post_revision($postId) || wp_is_post_autosave($postId)) {
|
return;
|
}
|
|
// error_log('[Clearing cache for post change: '.$postId.']');
|
self::invalidateItem('post', $postId);
|
}
|
|
public static function onPostDelete(int $postId): void
|
{
|
// error_log('[Clearing cache for post delete: '.$postId.']');
|
self::invalidateItem('post', $postId);
|
}
|
|
public static function onPostMetaChange(int $metaId, int $objectId): void
|
{
|
// error_log('[Clearing cache for post meta change: '.$objectId.']');
|
self::invalidateItem('post', $objectId);
|
}
|
|
public static function onPostMetaDelete(array $metaIds, int $objectId): void
|
{
|
// error_log('[Clearing cache for post meta delete: '.$objectId.']');
|
self::invalidateItem('post', $objectId);
|
}
|
|
/****************************************************
|
* HOOKS - Terms
|
****************************************************/
|
public static function onTermChange(int $termId, int $ttId, string $taxonomy): void
|
{
|
// error_log('[Clearing cache for term change: '.$termId.']');
|
self::invalidateItem('taxonomy', $termId);
|
}
|
|
public static function onTermDelete(int $termId): void
|
{
|
// error_log('[Clearing cache for term delete: '.$termId.']');
|
self::invalidateItem('taxonomy', $termId);
|
}
|
|
public static function onTermMetaChange(int $metaId, int $objectId): void
|
{
|
// error_log('[Clearing cache for term meta change: '.$objectId.']');
|
self::invalidateItem('taxonomy', $objectId);
|
}
|
|
public static function onTermMetaDelete(array $metaIds, int $objectId): void
|
{
|
// error_log('[Clearing cache for term meta delete: '.$objectId.']');
|
self::invalidateItem('taxonomy', $objectId);
|
}
|
|
/****************************************************
|
* HOOKS - Users
|
****************************************************/
|
public static function onUserChange(int $userId): void
|
{
|
// error_log('[Clearing cache for user change: '.$userId.']');
|
self::invalidateItem('user', $userId);
|
}
|
|
public static function onUserDelete(int $userId): void
|
{
|
// error_log('[Clearing cache for user delete: '.$userId.']');
|
self::invalidateItem('user', $userId);
|
}
|
|
public static function onUserMetaChange(int $metaId, int $objectId): void
|
{
|
// error_log('[Clearing cache for user meta change: '.$objectId.']');
|
self::invalidateItem('user', $objectId);
|
}
|
|
public static function onUserMetaDelete(array $metaIds, int $objectId): void
|
{
|
// error_log('[Clearing cache for user meta delete: '.$objectId.']');
|
self::invalidateItem('user', $objectId);
|
}
|
/***************************************************
|
* UTILITY
|
**************************************************/
|
/**
|
* Generate a cache key from parameters
|
* Useful for caching based on multiple variables
|
*
|
* @param array $params Key-value pairs that uniquely identify this cache entry
|
* @return string MD5 hash of sorted parameters
|
*/
|
public function generateKey(array $params): string
|
{
|
ksort($params);
|
return md5(serialize($params));
|
}
|
|
/**
|
* Nuclear option: Flush ALL registered cache groups
|
* Use for debugging or after major updates
|
*
|
* @return int Number of groups flushed
|
*/
|
public static function flushAll(): int
|
{
|
$all = self::connections();
|
$groups = [];
|
|
// Collect all unique groups from connections
|
foreach ($all as $source => $targets) {
|
$groups[$source] = true;
|
foreach ($targets as $conn) {
|
$target = $conn['target'] ?? $conn;
|
$groups[$target] = true;
|
}
|
}
|
|
// Add any instantiated groups not in connections
|
foreach (array_keys(self::$instances) as $group) {
|
$groups[$group] = true;
|
}
|
|
// Flush each group
|
$count = 0;
|
foreach (array_keys($groups) as $group) {
|
self::invalidateGroup($group);
|
$count++;
|
}
|
|
// Also flush timestamp cache
|
if (wp_using_ext_object_cache()) {
|
wp_cache_flush_group(self::TS_GROUP);
|
}
|
|
// Clear in-memory caches
|
self::$timestamps = [];
|
|
return $count;
|
}
|
|
/**
|
* Get all cache groups and their connections for admin display
|
*
|
* @return array Format: ['group' => ['connects_to' => [...], 'connected_from' => [...]]]
|
*/
|
public static function getAllGroups(): array
|
{
|
$connections = self::connections();
|
$groups = [];
|
|
// Build bidirectional view
|
foreach ($connections as $source => $targets) {
|
if (!isset($groups[$source])) {
|
$groups[$source] = ['connects_to' => [], 'connected_from' => []];
|
}
|
|
foreach ($targets as $conn) {
|
$target = $conn['target'] ?? $conn;
|
$flush = $conn['flush'] ?? false;
|
|
// Source connects to target
|
$groups[$source]['connects_to'][] = [
|
'group' => $target,
|
'flush' => $flush
|
];
|
|
// Target is connected from source
|
if (!isset($groups[$target])) {
|
$groups[$target] = ['connects_to' => [], 'connected_from' => []];
|
}
|
$groups[$target]['connected_from'][] = [
|
'group' => $source,
|
'flush' => $flush
|
];
|
}
|
}
|
|
// Add any instantiated groups not in connections
|
foreach (array_keys(self::$instances) as $group) {
|
if (!isset($groups[$group])) {
|
$groups[$group] = ['connects_to' => [], 'connected_from' => []];
|
}
|
}
|
|
return $groups;
|
}
|
|
public function hasRedis():bool
|
{
|
return $this->hasRedis;
|
}
|
}
|
