FOUR-20911: Caching Screens

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class LegacyScreenCacheAdapter implements ScreenCacheInterface
+{
+ protected ScreenCompiledManager $compiledManager;
+
+ public function __construct(ScreenCompiledManager $compiledManager)
+ {
+ $this->compiledManager = $compiledManager;
+ }
+
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return $this->compiledManager->createKey(
+ (string) $processId,
+ (string) $processVersionId,
+ $language,
+ (string) $screenId,
+ (string) $screenVersionId
+ );
+ }
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $content = $this->compiledManager->getCompiledContent($key);
+
+ return $content ?? $default;
+ }
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool
+ {
+ $this->compiledManager->storeCompiledContent($key, $value);
+
+ return true;
+ }
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool
+ {
+ return $this->compiledManager->getCompiledContent($key) !== null;
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFacade.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * Class ScreenCacheFacade
+ *
+ * @mixin \ProcessMaker\Cache\Settings\ScreenCacheManager
+ */
+class ScreenCacheFacade extends Facade
+{
+ protected static function getFacadeAccessor()
+ {
+ return 'screen.cache';
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheFactory
+{
+ private static ?ScreenCacheInterface $testInstance = null;
+
+ /**
+ * Set a test instance for the factory
+ *
+ * @param ScreenCacheInterface|null $instance
+ */
+ public static function setTestInstance(?ScreenCacheInterface $instance): void
+ {
+ self::$testInstance = $instance;
+ }
+
+ /**
+ * Create a screen cache handler based on configuration
+ *
+ * @return ScreenCacheInterface
+ */
+ public static function create(): ScreenCacheInterface
+ {
+ if (self::$testInstance !== null) {
+ return self::$testInstance;
+ }
+
+ $manager = Config::get('screens.cache.manager', 'legacy');
+
+ if ($manager === 'new') {
+ return app(ScreenCacheManager::class);
+ }
+
+ // Get the concrete ScreenCompiledManager instance from the container
+ $compiledManager = app()->make(ScreenCompiledManager::class);
+
+ return new LegacyScreenCacheAdapter($compiledManager);
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+interface ScreenCacheInterface
+{
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed;
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool;
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool;
+}

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+{
+ protected CacheManager $cacheManager;
+
+ protected ScreenCompiledManager $screenCompiler;
+
+ /**
+ * Default TTL for cached screens (24 hours)
+ */
+ protected const DEFAULT_TTL = 86400;
+
+ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $screenCompiler)
+ {
+ $this->cacheManager = $cacheManager;
+ $this->screenCompiler = $screenCompiler;
+ }
+
+ /**
+ * Create a cache key for a screen
+ *
+ * @param int $processId Process ID
+ * @param int $processVersionId Process version ID
+ * @param string $language Language code
+ * @param int $screenId Screen ID
+ * @param int $screenVersionId Screen version ID
+ * @return string Cache key
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+ }
+
+ /**
+ * Get a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $default Default value
+ * @return mixed
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $serializedContent = $this->cacheManager->get($key);
+ if ($serializedContent !== null) {
+ return unserialize($serializedContent);
+ }
+
+ return $default;
+ }
+
+ /**
+ * Store a screen in memory cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $value Compiled screen content
+ * @param null|int|\DateInterval $ttl Time to live
+ * @return bool
+ */
+ public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+ {
+ $serializedContent = serialize($value);
+
+ return $this->cacheManager->put($key, $serializedContent, $ttl ?? self::DEFAULT_TTL);
+ }
+
+ /**
+ * Delete a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function delete(string $key): bool
+ {
+ return $this->cacheManager->forget($key);
+ }
+
+ /**
+ * Clear all screen caches
+ *
+ * @return bool
+ */
+ public function clear(): bool
+ {
+ return $this->cacheManager->flush();
+ }
+
+ /**
+ * Check if screen exists in cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function has(string $key): bool
+ {
+ return $this->cacheManager->has($key);
+ }
+
+ /**
+ * Check if screen is missing
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function missing(string $key): bool
+ {
+ return !$this->has($key);
+ }
+}

ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php

@@ -7,7 +7,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use ProcessMaker\Facades\ScreenCompiledManager;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\V1_1\TaskInterstitialResource;
 use ProcessMaker\Http\Resources\V1_1\TaskResource;
@@ -102,31 +102,43 @@ public function showScreen($taskId)
  $task = ProcessRequestToken::select(
  array_merge($this->defaultFields, ['process_request_id', 'process_id'])
  )
- // eager loading process_request.process_version_id
  ->with([
- 'processRequest'=> function ($query) {
+ 'processRequest'=> function ($query) {
  $query->select('id', 'process_version_id');
  },
  ])->findOrFail($taskId);
 
- // Prepare the key for the screen cache
+ // Get screen version and prepare cache key
  $processId = $task->process_id;
  $processVersionId = $task->processRequest->process_version_id;
  $language = TranslationManager::getTargetLanguage();
  $screenVersion = $task->getScreenVersion();
- $key = ScreenCompiledManager::createKey($processId, $processVersionId, $language, $screenVersion->screen_id, $screenVersion->id);
 
- // Get the screen content from the cache or compile it
- $translatedScreen = ScreenCompiledManager::getCompiledContent($key);
- if (!isset($translatedScreen)) {
+ // Get the appropriate cache handler based on configuration
+ $screenCache = ScreenCacheFactory::create();
+
+ // Create cache key
+ $key = $screenCache->createKey(
+ (int) $processId,
+ (int) $processVersionId,
+ $language,
+ (int) $screenVersion->screen_id,
+ (int) $screenVersion->id
+ );
+
+ // Try to get the screen from cache
+ $translatedScreen = $screenCache->get($key);
+
+ if ($translatedScreen === null) {
+ // If not in cache, create new response
  $response = new TaskScreen($task);
  $translatedScreen = $response->toArray(request())['screen'];
- ScreenCompiledManager::storeCompiledContent($key, $translatedScreen);
- }
 
- $response = response($translatedScreen, 200);
+ // Store in cache
+ $screenCache->set($key, $translatedScreen);
+ }
 
- return $response;
+ return response($translatedScreen, 200);
  }
 
  public function showInterstitial($taskId)

config/screens.php

@@ -0,0 +1,23 @@
+<?php
+
+return [
+ /*
+ |--------------------------------------------------------------------------
+ | Screen Cache Configuration
+ |--------------------------------------------------------------------------
+ |
+ | Here you can configure the screen caching behavior.
+ |
+ */
+
+ 'cache' => [
+ // Cache manager to use: 'new' for ScreenCacheManager, 'legacy' for ScreenCompiledManager
+ 'manager' => env('SCREEN_CACHE_MANAGER', 'legacy'),
+
+ // Cache driver to use (redis, file)
+ 'driver' => env('SCREEN_CACHE_DRIVER', 'file'),
+
+ // Default TTL for cached screens (24 hours)
+ 'ttl' => env('SCREEN_CACHE_TTL', 86400),
+ ],
+];

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class LegacyScreenCacheAdapter implements ScreenCacheInterface
+{
+ protected ScreenCompiledManager $compiledManager;
+
+ public function __construct(ScreenCompiledManager $compiledManager)
+ {
+ $this->compiledManager = $compiledManager;
+ }
+
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return $this->compiledManager->createKey(
+ (string) $processId,
+ (string) $processVersionId,
+ $language,
+ (string) $screenId,
+ (string) $screenVersionId
+ );
+ }
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $content = $this->compiledManager->getCompiledContent($key);
+
+ return $content ?? $default;
+ }
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool
+ {
+ $this->compiledManager->storeCompiledContent($key, $value);
+
+ return true;
+ }
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool
+ {
+ return $this->compiledManager->getCompiledContent($key) !== null;
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFacade.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * Class ScreenCacheFacade
+ *
+ * @mixin \ProcessMaker\Cache\Settings\ScreenCacheManager
+ */
+class ScreenCacheFacade extends Facade
+{
+ protected static function getFacadeAccessor()
+ {
+ return 'screen.cache';
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheFactory
+{
+ private static ?ScreenCacheInterface $testInstance = null;
+
+ /**
+ * Set a test instance for the factory
+ *
+ * @param ScreenCacheInterface|null $instance
+ */
+ public static function setTestInstance(?ScreenCacheInterface $instance): void
+ {
+ self::$testInstance = $instance;
+ }
+
+ /**
+ * Create a screen cache handler based on configuration
+ *
+ * @return ScreenCacheInterface
+ */
+ public static function create(): ScreenCacheInterface
+ {
+ if (self::$testInstance !== null) {
+ return self::$testInstance;
+ }
+
+ $manager = Config::get('screens.cache.manager', 'legacy');
+
+ if ($manager === 'new') {
+ return app(ScreenCacheManager::class);
+ }
+
+ // Get the concrete ScreenCompiledManager instance from the container
+ $compiledManager = app()->make(ScreenCompiledManager::class);
+
+ return new LegacyScreenCacheAdapter($compiledManager);
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+interface ScreenCacheInterface
+{
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed;
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool;
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool;
+}

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+{
+ protected CacheManager $cacheManager;
+
+ protected ScreenCompiledManager $screenCompiler;
+
+ /**
+ * Default TTL for cached screens (24 hours)
+ */
+ protected const DEFAULT_TTL = 86400;
+
+ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $screenCompiler)
+ {
+ $this->cacheManager = $cacheManager;
+ $this->screenCompiler = $screenCompiler;
+ }
+
+ /**
+ * Create a cache key for a screen
+ *
+ * @param int $processId Process ID
+ * @param int $processVersionId Process version ID
+ * @param string $language Language code
+ * @param int $screenId Screen ID
+ * @param int $screenVersionId Screen version ID
+ * @return string Cache key
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+ }
+
+ /**
+ * Get a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $default Default value
+ * @return mixed
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $serializedContent = $this->cacheManager->get($key);
+ if ($serializedContent !== null) {
+ return unserialize($serializedContent);
+ }
+
+ return $default;
+ }
+
+ /**
+ * Store a screen in memory cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $value Compiled screen content
+ * @param null|int|\DateInterval $ttl Time to live
+ * @return bool
+ */
+ public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+ {
+ $serializedContent = serialize($value);
+
+ return $this->cacheManager->put($key, $serializedContent, $ttl ?? self::DEFAULT_TTL);
+ }
+
+ /**
+ * Delete a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function delete(string $key): bool
+ {
+ return $this->cacheManager->forget($key);
+ }
+
+ /**
+ * Clear all screen caches
+ *
+ * @return bool
+ */
+ public function clear(): bool
+ {
+ return $this->cacheManager->flush();
+ }
+
+ /**
+ * Check if screen exists in cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function has(string $key): bool
+ {
+ return $this->cacheManager->has($key);
+ }
+
+ /**
+ * Check if screen is missing
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function missing(string $key): bool
+ {
+ return !$this->has($key);
+ }
+}

ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php

@@ -7,7 +7,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use ProcessMaker\Facades\ScreenCompiledManager;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\V1_1\TaskInterstitialResource;
 use ProcessMaker\Http\Resources\V1_1\TaskResource;
@@ -102,31 +102,43 @@ public function showScreen($taskId)
  $task = ProcessRequestToken::select(
  array_merge($this->defaultFields, ['process_request_id', 'process_id'])
  )
- // eager loading process_request.process_version_id
  ->with([
- 'processRequest'=> function ($query) {
+ 'processRequest'=> function ($query) {
  $query->select('id', 'process_version_id');
  },
  ])->findOrFail($taskId);
 
- // Prepare the key for the screen cache
+ // Get screen version and prepare cache key
  $processId = $task->process_id;
  $processVersionId = $task->processRequest->process_version_id;
  $language = TranslationManager::getTargetLanguage();
  $screenVersion = $task->getScreenVersion();
- $key = ScreenCompiledManager::createKey($processId, $processVersionId, $language, $screenVersion->screen_id, $screenVersion->id);
 
- // Get the screen content from the cache or compile it
- $translatedScreen = ScreenCompiledManager::getCompiledContent($key);
- if (!isset($translatedScreen)) {
+ // Get the appropriate cache handler based on configuration
+ $screenCache = ScreenCacheFactory::create();
+
+ // Create cache key
+ $key = $screenCache->createKey(
+ (int) $processId,
+ (int) $processVersionId,
+ $language,
+ (int) $screenVersion->screen_id,
+ (int) $screenVersion->id
+ );
+
+ // Try to get the screen from cache
+ $translatedScreen = $screenCache->get($key);
+
+ if ($translatedScreen === null) {
+ // If not in cache, create new response
  $response = new TaskScreen($task);
  $translatedScreen = $response->toArray(request())['screen'];
- ScreenCompiledManager::storeCompiledContent($key, $translatedScreen);
- }
 
- $response = response($translatedScreen, 200);
+ // Store in cache
+ $screenCache->set($key, $translatedScreen);
+ }
 
- return $response;
+ return response($translatedScreen, 200);
  }
 
  public function showInterstitial($taskId)

config/screens.php

@@ -0,0 +1,23 @@
+<?php
+
+return [
+ /*
+ |--------------------------------------------------------------------------
+ | Screen Cache Configuration
+ |--------------------------------------------------------------------------
+ |
+ | Here you can configure the screen caching behavior.
+ |
+ */
+
+ 'cache' => [
+ // Cache manager to use: 'new' for ScreenCacheManager, 'legacy' for ScreenCompiledManager
+ 'manager' => env('SCREEN_CACHE_MANAGER', 'legacy'),
+
+ // Cache driver to use (redis, file)
+ 'driver' => env('SCREEN_CACHE_DRIVER', 'file'),
+
+ // Default TTL for cached screens (24 hours)
+ 'ttl' => env('SCREEN_CACHE_TTL', 86400),
+ ],
+];

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class LegacyScreenCacheAdapter implements ScreenCacheInterface
+{
+ protected ScreenCompiledManager $compiledManager;
+
+ public function __construct(ScreenCompiledManager $compiledManager)
+ {
+ $this->compiledManager = $compiledManager;
+ }
+
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return $this->compiledManager->createKey(
+ (string) $processId,
+ (string) $processVersionId,
+ $language,
+ (string) $screenId,
+ (string) $screenVersionId
+ );
+ }
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $content = $this->compiledManager->getCompiledContent($key);
+
+ return $content ?? $default;
+ }
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool
+ {
+ $this->compiledManager->storeCompiledContent($key, $value);
+
+ return true;
+ }
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool
+ {
+ return $this->compiledManager->getCompiledContent($key) !== null;
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFacade.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * Class ScreenCacheFacade
+ *
+ * @mixin \ProcessMaker\Cache\Settings\ScreenCacheManager
+ */
+class ScreenCacheFacade extends Facade
+{
+ protected static function getFacadeAccessor()
+ {
+ return 'screen.cache';
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheFactory
+{
+ private static ?ScreenCacheInterface $testInstance = null;
+
+ /**
+ * Set a test instance for the factory
+ *
+ * @param ScreenCacheInterface|null $instance
+ */
+ public static function setTestInstance(?ScreenCacheInterface $instance): void
+ {
+ self::$testInstance = $instance;
+ }
+
+ /**
+ * Create a screen cache handler based on configuration
+ *
+ * @return ScreenCacheInterface
+ */
+ public static function create(): ScreenCacheInterface
+ {
+ if (self::$testInstance !== null) {
+ return self::$testInstance;
+ }
+
+ $manager = Config::get('screens.cache.manager', 'legacy');
+
+ if ($manager === 'new') {
+ return app(ScreenCacheManager::class);
+ }
+
+ // Get the concrete ScreenCompiledManager instance from the container
+ $compiledManager = app()->make(ScreenCompiledManager::class);
+
+ return new LegacyScreenCacheAdapter($compiledManager);
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+interface ScreenCacheInterface
+{
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed;
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool;
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool;
+}

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+{
+ protected CacheManager $cacheManager;
+
+ protected ScreenCompiledManager $screenCompiler;
+
+ /**
+ * Default TTL for cached screens (24 hours)
+ */
+ protected const DEFAULT_TTL = 86400;
+
+ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $screenCompiler)
+ {
+ $this->cacheManager = $cacheManager;
+ $this->screenCompiler = $screenCompiler;
+ }
+
+ /**
+ * Create a cache key for a screen
+ *
+ * @param int $processId Process ID
+ * @param int $processVersionId Process version ID
+ * @param string $language Language code
+ * @param int $screenId Screen ID
+ * @param int $screenVersionId Screen version ID
+ * @return string Cache key
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+ }
+
+ /**
+ * Get a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $default Default value
+ * @return mixed
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $serializedContent = $this->cacheManager->get($key);
+ if ($serializedContent !== null) {
+ return unserialize($serializedContent);
+ }
+
+ return $default;
+ }
+
+ /**
+ * Store a screen in memory cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $value Compiled screen content
+ * @param null|int|\DateInterval $ttl Time to live
+ * @return bool
+ */
+ public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+ {
+ $serializedContent = serialize($value);
+
+ return $this->cacheManager->put($key, $serializedContent, $ttl ?? self::DEFAULT_TTL);
+ }
+
+ /**
+ * Delete a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function delete(string $key): bool
+ {
+ return $this->cacheManager->forget($key);
+ }
+
+ /**
+ * Clear all screen caches
+ *
+ * @return bool
+ */
+ public function clear(): bool
+ {
+ return $this->cacheManager->flush();
+ }
+
+ /**
+ * Check if screen exists in cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function has(string $key): bool
+ {
+ return $this->cacheManager->has($key);
+ }
+
+ /**
+ * Check if screen is missing
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function missing(string $key): bool
+ {
+ return !$this->has($key);
+ }
+}

ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php

@@ -7,7 +7,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use ProcessMaker\Facades\ScreenCompiledManager;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\V1_1\TaskInterstitialResource;
 use ProcessMaker\Http\Resources\V1_1\TaskResource;
@@ -102,31 +102,43 @@ public function showScreen($taskId)
  $task = ProcessRequestToken::select(
  array_merge($this->defaultFields, ['process_request_id', 'process_id'])
  )
- // eager loading process_request.process_version_id
  ->with([
- 'processRequest'=> function ($query) {
+ 'processRequest'=> function ($query) {
  $query->select('id', 'process_version_id');
  },
  ])->findOrFail($taskId);
 
- // Prepare the key for the screen cache
+ // Get screen version and prepare cache key
  $processId = $task->process_id;
  $processVersionId = $task->processRequest->process_version_id;
  $language = TranslationManager::getTargetLanguage();
  $screenVersion = $task->getScreenVersion();
- $key = ScreenCompiledManager::createKey($processId, $processVersionId, $language, $screenVersion->screen_id, $screenVersion->id);
 
- // Get the screen content from the cache or compile it
- $translatedScreen = ScreenCompiledManager::getCompiledContent($key);
- if (!isset($translatedScreen)) {
+ // Get the appropriate cache handler based on configuration
+ $screenCache = ScreenCacheFactory::create();
+
+ // Create cache key
+ $key = $screenCache->createKey(
+ (int) $processId,
+ (int) $processVersionId,
+ $language,
+ (int) $screenVersion->screen_id,
+ (int) $screenVersion->id
+ );
+
+ // Try to get the screen from cache
+ $translatedScreen = $screenCache->get($key);
+
+ if ($translatedScreen === null) {
+ // If not in cache, create new response
  $response = new TaskScreen($task);
  $translatedScreen = $response->toArray(request())['screen'];
- ScreenCompiledManager::storeCompiledContent($key, $translatedScreen);
- }
 
- $response = response($translatedScreen, 200);
+ // Store in cache
+ $screenCache->set($key, $translatedScreen);
+ }
 
- return $response;
+ return response($translatedScreen, 200);
  }
 
  public function showInterstitial($taskId)

config/screens.php

@@ -0,0 +1,23 @@
+<?php
+
+return [
+ /*
+ |--------------------------------------------------------------------------
+ | Screen Cache Configuration
+ |--------------------------------------------------------------------------
+ |
+ | Here you can configure the screen caching behavior.
+ |
+ */
+
+ 'cache' => [
+ // Cache manager to use: 'new' for ScreenCacheManager, 'legacy' for ScreenCompiledManager
+ 'manager' => env('SCREEN_CACHE_MANAGER', 'legacy'),
+
+ // Cache driver to use (redis, file)
+ 'driver' => env('SCREEN_CACHE_DRIVER', 'file'),
+
+ // Default TTL for cached screens (24 hours)
+ 'ttl' => env('SCREEN_CACHE_TTL', 86400),
+ ],
+];

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class LegacyScreenCacheAdapter implements ScreenCacheInterface
+{
+ protected ScreenCompiledManager $compiledManager;
+
+ public function __construct(ScreenCompiledManager $compiledManager)
+ {
+ $this->compiledManager = $compiledManager;
+ }
+
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return $this->compiledManager->createKey(
+ (string) $processId,
+ (string) $processVersionId,
+ $language,
+ (string) $screenId,
+ (string) $screenVersionId
+ );
+ }
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $content = $this->compiledManager->getCompiledContent($key);
+
+ return $content ?? $default;
+ }
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool
+ {
+ $this->compiledManager->storeCompiledContent($key, $value);
+
+ return true;
+ }
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool
+ {
+ return $this->compiledManager->getCompiledContent($key) !== null;
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFacade.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * Class ScreenCacheFacade
+ *
+ * @mixin \ProcessMaker\Cache\Settings\ScreenCacheManager
+ */
+class ScreenCacheFacade extends Facade
+{
+ protected static function getFacadeAccessor()
+ {
+ return 'screen.cache';
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheFactory
+{
+ private static ?ScreenCacheInterface $testInstance = null;
+
+ /**
+ * Set a test instance for the factory
+ *
+ * @param ScreenCacheInterface|null $instance
+ */
+ public static function setTestInstance(?ScreenCacheInterface $instance): void
+ {
+ self::$testInstance = $instance;
+ }
+
+ /**
+ * Create a screen cache handler based on configuration
+ *
+ * @return ScreenCacheInterface
+ */
+ public static function create(): ScreenCacheInterface
+ {
+ if (self::$testInstance !== null) {
+ return self::$testInstance;
+ }
+
+ $manager = Config::get('screens.cache.manager', 'legacy');
+
+ if ($manager === 'new') {
+ return app(ScreenCacheManager::class);
+ }
+
+ // Get the concrete ScreenCompiledManager instance from the container
+ $compiledManager = app()->make(ScreenCompiledManager::class);
+
+ return new LegacyScreenCacheAdapter($compiledManager);
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+interface ScreenCacheInterface
+{
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed;
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool;
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool;
+}

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+{
+ protected CacheManager $cacheManager;
+
+ protected ScreenCompiledManager $screenCompiler;
+
+ /**
+ * Default TTL for cached screens (24 hours)
+ */
+ protected const DEFAULT_TTL = 86400;
+
+ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $screenCompiler)
+ {
+ $this->cacheManager = $cacheManager;
+ $this->screenCompiler = $screenCompiler;
+ }
+
+ /**
+ * Create a cache key for a screen
+ *
+ * @param int $processId Process ID
+ * @param int $processVersionId Process version ID
+ * @param string $language Language code
+ * @param int $screenId Screen ID
+ * @param int $screenVersionId Screen version ID
+ * @return string Cache key
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+ }
+
+ /**
+ * Get a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $default Default value
+ * @return mixed
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $serializedContent = $this->cacheManager->get($key);
+ if ($serializedContent !== null) {
+ return unserialize($serializedContent);
+ }
+
+ return $default;
+ }
+
+ /**
+ * Store a screen in memory cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $value Compiled screen content
+ * @param null|int|\DateInterval $ttl Time to live
+ * @return bool
+ */
+ public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+ {
+ $serializedContent = serialize($value);
+
+ return $this->cacheManager->put($key, $serializedContent, $ttl ?? self::DEFAULT_TTL);
+ }
+
+ /**
+ * Delete a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function delete(string $key): bool
+ {
+ return $this->cacheManager->forget($key);
+ }
+
+ /**
+ * Clear all screen caches
+ *
+ * @return bool
+ */
+ public function clear(): bool
+ {
+ return $this->cacheManager->flush();
+ }
+
+ /**
+ * Check if screen exists in cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function has(string $key): bool
+ {
+ return $this->cacheManager->has($key);
+ }
+
+ /**
+ * Check if screen is missing
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function missing(string $key): bool
+ {
+ return !$this->has($key);
+ }
+}

ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php

@@ -7,7 +7,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use ProcessMaker\Facades\ScreenCompiledManager;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\V1_1\TaskInterstitialResource;
 use ProcessMaker\Http\Resources\V1_1\TaskResource;
@@ -102,31 +102,43 @@ public function showScreen($taskId)
  $task = ProcessRequestToken::select(
  array_merge($this->defaultFields, ['process_request_id', 'process_id'])
  )
- // eager loading process_request.process_version_id
  ->with([
- 'processRequest'=> function ($query) {
+ 'processRequest'=> function ($query) {
  $query->select('id', 'process_version_id');
  },
  ])->findOrFail($taskId);
 
- // Prepare the key for the screen cache
+ // Get screen version and prepare cache key
  $processId = $task->process_id;
  $processVersionId = $task->processRequest->process_version_id;
  $language = TranslationManager::getTargetLanguage();
  $screenVersion = $task->getScreenVersion();
- $key = ScreenCompiledManager::createKey($processId, $processVersionId, $language, $screenVersion->screen_id, $screenVersion->id);
 
- // Get the screen content from the cache or compile it
- $translatedScreen = ScreenCompiledManager::getCompiledContent($key);
- if (!isset($translatedScreen)) {
+ // Get the appropriate cache handler based on configuration
+ $screenCache = ScreenCacheFactory::create();
+
+ // Create cache key
+ $key = $screenCache->createKey(
+ (int) $processId,
+ (int) $processVersionId,
+ $language,
+ (int) $screenVersion->screen_id,
+ (int) $screenVersion->id
+ );
+
+ // Try to get the screen from cache
+ $translatedScreen = $screenCache->get($key);
+
+ if ($translatedScreen === null) {
+ // If not in cache, create new response
  $response = new TaskScreen($task);
  $translatedScreen = $response->toArray(request())['screen'];
- ScreenCompiledManager::storeCompiledContent($key, $translatedScreen);
- }
 
- $response = response($translatedScreen, 200);
+ // Store in cache
+ $screenCache->set($key, $translatedScreen);
+ }
 
- return $response;
+ return response($translatedScreen, 200);
  }
 
  public function showInterstitial($taskId)

config/screens.php

@@ -0,0 +1,23 @@
+<?php
+
+return [
+ /*
+ |--------------------------------------------------------------------------
+ | Screen Cache Configuration
+ |--------------------------------------------------------------------------
+ |
+ | Here you can configure the screen caching behavior.
+ |
+ */
+
+ 'cache' => [
+ // Cache manager to use: 'new' for ScreenCacheManager, 'legacy' for ScreenCompiledManager
+ 'manager' => env('SCREEN_CACHE_MANAGER', 'legacy'),
+
+ // Cache driver to use (redis, file)
+ 'driver' => env('SCREEN_CACHE_DRIVER', 'file'),
+
+ // Default TTL for cached screens (24 hours)
+ 'ttl' => env('SCREEN_CACHE_TTL', 86400),
+ ],
+];

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class LegacyScreenCacheAdapter implements ScreenCacheInterface
+{
+ protected ScreenCompiledManager $compiledManager;
+
+ public function __construct(ScreenCompiledManager $compiledManager)
+ {
+ $this->compiledManager = $compiledManager;
+ }
+
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return $this->compiledManager->createKey(
+ (string) $processId,
+ (string) $processVersionId,
+ $language,
+ (string) $screenId,
+ (string) $screenVersionId
+ );
+ }
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $content = $this->compiledManager->getCompiledContent($key);
+
+ return $content ?? $default;
+ }
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool
+ {
+ $this->compiledManager->storeCompiledContent($key, $value);
+
+ return true;
+ }
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool
+ {
+ return $this->compiledManager->getCompiledContent($key) !== null;
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFacade.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * Class ScreenCacheFacade
+ *
+ * @mixin \ProcessMaker\Cache\Settings\ScreenCacheManager
+ */
+class ScreenCacheFacade extends Facade
+{
+ protected static function getFacadeAccessor()
+ {
+ return 'screen.cache';
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheFactory
+{
+ private static ?ScreenCacheInterface $testInstance = null;
+
+ /**
+ * Set a test instance for the factory
+ *
+ * @param ScreenCacheInterface|null $instance
+ */
+ public static function setTestInstance(?ScreenCacheInterface $instance): void
+ {
+ self::$testInstance = $instance;
+ }
+
+ /**
+ * Create a screen cache handler based on configuration
+ *
+ * @return ScreenCacheInterface
+ */
+ public static function create(): ScreenCacheInterface
+ {
+ if (self::$testInstance !== null) {
+ return self::$testInstance;
+ }
+
+ $manager = Config::get('screens.cache.manager', 'legacy');
+
+ if ($manager === 'new') {
+ return app(ScreenCacheManager::class);
+ }
+
+ // Get the concrete ScreenCompiledManager instance from the container
+ $compiledManager = app()->make(ScreenCompiledManager::class);
+
+ return new LegacyScreenCacheAdapter($compiledManager);
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+interface ScreenCacheInterface
+{
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed;
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool;
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool;
+}

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+{
+ protected CacheManager $cacheManager;
+
+ protected ScreenCompiledManager $screenCompiler;
+
+ /**
+ * Default TTL for cached screens (24 hours)
+ */
+ protected const DEFAULT_TTL = 86400;
+
+ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $screenCompiler)
+ {
+ $this->cacheManager = $cacheManager;
+ $this->screenCompiler = $screenCompiler;
+ }
+
+ /**
+ * Create a cache key for a screen
+ *
+ * @param int $processId Process ID
+ * @param int $processVersionId Process version ID
+ * @param string $language Language code
+ * @param int $screenId Screen ID
+ * @param int $screenVersionId Screen version ID
+ * @return string Cache key
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+ }
+
+ /**
+ * Get a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $default Default value
+ * @return mixed
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $serializedContent = $this->cacheManager->get($key);
+ if ($serializedContent !== null) {
+ return unserialize($serializedContent);
+ }
+
+ return $default;
+ }
+
+ /**
+ * Store a screen in memory cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $value Compiled screen content
+ * @param null|int|\DateInterval $ttl Time to live
+ * @return bool
+ */
+ public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+ {
+ $serializedContent = serialize($value);
+
+ return $this->cacheManager->put($key, $serializedContent, $ttl ?? self::DEFAULT_TTL);
+ }
+
+ /**
+ * Delete a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function delete(string $key): bool
+ {
+ return $this->cacheManager->forget($key);
+ }
+
+ /**
+ * Clear all screen caches
+ *
+ * @return bool
+ */
+ public function clear(): bool
+ {
+ return $this->cacheManager->flush();
+ }
+
+ /**
+ * Check if screen exists in cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function has(string $key): bool
+ {
+ return $this->cacheManager->has($key);
+ }
+
+ /**
+ * Check if screen is missing
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function missing(string $key): bool
+ {
+ return !$this->has($key);
+ }
+}

ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php

@@ -7,7 +7,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use ProcessMaker\Facades\ScreenCompiledManager;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\V1_1\TaskInterstitialResource;
 use ProcessMaker\Http\Resources\V1_1\TaskResource;
@@ -102,31 +102,43 @@ public function showScreen($taskId)
  $task = ProcessRequestToken::select(
  array_merge($this->defaultFields, ['process_request_id', 'process_id'])
  )
- // eager loading process_request.process_version_id
  ->with([
- 'processRequest'=> function ($query) {
+ 'processRequest'=> function ($query) {
  $query->select('id', 'process_version_id');
  },
  ])->findOrFail($taskId);
 
- // Prepare the key for the screen cache
+ // Get screen version and prepare cache key
  $processId = $task->process_id;
  $processVersionId = $task->processRequest->process_version_id;
  $language = TranslationManager::getTargetLanguage();
  $screenVersion = $task->getScreenVersion();
- $key = ScreenCompiledManager::createKey($processId, $processVersionId, $language, $screenVersion->screen_id, $screenVersion->id);
 
- // Get the screen content from the cache or compile it
- $translatedScreen = ScreenCompiledManager::getCompiledContent($key);
- if (!isset($translatedScreen)) {
+ // Get the appropriate cache handler based on configuration
+ $screenCache = ScreenCacheFactory::create();
+
+ // Create cache key
+ $key = $screenCache->createKey(
+ (int) $processId,
+ (int) $processVersionId,
+ $language,
+ (int) $screenVersion->screen_id,
+ (int) $screenVersion->id
+ );
+
+ // Try to get the screen from cache
+ $translatedScreen = $screenCache->get($key);
+
+ if ($translatedScreen === null) {
+ // If not in cache, create new response
  $response = new TaskScreen($task);
  $translatedScreen = $response->toArray(request())['screen'];
- ScreenCompiledManager::storeCompiledContent($key, $translatedScreen);
- }
 
- $response = response($translatedScreen, 200);
+ // Store in cache
+ $screenCache->set($key, $translatedScreen);
+ }
 
- return $response;
+ return response($translatedScreen, 200);
  }
 
  public function showInterstitial($taskId)

config/screens.php

@@ -0,0 +1,23 @@
+<?php
+
+return [
+ /*
+ |--------------------------------------------------------------------------
+ | Screen Cache Configuration
+ |--------------------------------------------------------------------------
+ |
+ | Here you can configure the screen caching behavior.
+ |
+ */
+
+ 'cache' => [
+ // Cache manager to use: 'new' for ScreenCacheManager, 'legacy' for ScreenCompiledManager
+ 'manager' => env('SCREEN_CACHE_MANAGER', 'legacy'),
+
+ // Cache driver to use (redis, file)
+ 'driver' => env('SCREEN_CACHE_DRIVER', 'file'),
+
+ // Default TTL for cached screens (24 hours)
+ 'ttl' => env('SCREEN_CACHE_TTL', 86400),
+ ],
+];

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class LegacyScreenCacheAdapter implements ScreenCacheInterface
+{
+ protected ScreenCompiledManager $compiledManager;
+
+ public function __construct(ScreenCompiledManager $compiledManager)
+ {
+ $this->compiledManager = $compiledManager;
+ }
+
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return $this->compiledManager->createKey(
+ (string) $processId,
+ (string) $processVersionId,
+ $language,
+ (string) $screenId,
+ (string) $screenVersionId
+ );
+ }
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $content = $this->compiledManager->getCompiledContent($key);
+
+ return $content ?? $default;
+ }
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool
+ {
+ $this->compiledManager->storeCompiledContent($key, $value);
+
+ return true;
+ }
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool
+ {
+ return $this->compiledManager->getCompiledContent($key) !== null;
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFacade.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * Class ScreenCacheFacade
+ *
+ * @mixin \ProcessMaker\Cache\Settings\ScreenCacheManager
+ */
+class ScreenCacheFacade extends Facade
+{
+ protected static function getFacadeAccessor()
+ {
+ return 'screen.cache';
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheFactory
+{
+ private static ?ScreenCacheInterface $testInstance = null;
+
+ /**
+ * Set a test instance for the factory
+ *
+ * @param ScreenCacheInterface|null $instance
+ */
+ public static function setTestInstance(?ScreenCacheInterface $instance): void
+ {
+ self::$testInstance = $instance;
+ }
+
+ /**
+ * Create a screen cache handler based on configuration
+ *
+ * @return ScreenCacheInterface
+ */
+ public static function create(): ScreenCacheInterface
+ {
+ if (self::$testInstance !== null) {
+ return self::$testInstance;
+ }
+
+ $manager = Config::get('screens.cache.manager', 'legacy');
+
+ if ($manager === 'new') {
+ return app(ScreenCacheManager::class);
+ }
+
+ // Get the concrete ScreenCompiledManager instance from the container
+ $compiledManager = app()->make(ScreenCompiledManager::class);
+
+ return new LegacyScreenCacheAdapter($compiledManager);
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+interface ScreenCacheInterface
+{
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed;
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool;
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool;
+}

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+{
+ protected CacheManager $cacheManager;
+
+ protected ScreenCompiledManager $screenCompiler;
+
+ /**
+ * Default TTL for cached screens (24 hours)
+ */
+ protected const DEFAULT_TTL = 86400;
+
+ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $screenCompiler)
+ {
+ $this->cacheManager = $cacheManager;
+ $this->screenCompiler = $screenCompiler;
+ }
+
+ /**
+ * Create a cache key for a screen
+ *
+ * @param int $processId Process ID
+ * @param int $processVersionId Process version ID
+ * @param string $language Language code
+ * @param int $screenId Screen ID
+ * @param int $screenVersionId Screen version ID
+ * @return string Cache key
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+ }
+
+ /**
+ * Get a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $default Default value
+ * @return mixed
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $serializedContent = $this->cacheManager->get($key);
+ if ($serializedContent !== null) {
+ return unserialize($serializedContent);
+ }
+
+ return $default;
+ }
+
+ /**
+ * Store a screen in memory cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $value Compiled screen content
+ * @param null|int|\DateInterval $ttl Time to live
+ * @return bool
+ */
+ public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+ {
+ $serializedContent = serialize($value);
+
+ return $this->cacheManager->put($key, $serializedContent, $ttl ?? self::DEFAULT_TTL);
+ }
+
+ /**
+ * Delete a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function delete(string $key): bool
+ {
+ return $this->cacheManager->forget($key);
+ }
+
+ /**
+ * Clear all screen caches
+ *
+ * @return bool
+ */
+ public function clear(): bool
+ {
+ return $this->cacheManager->flush();
+ }
+
+ /**
+ * Check if screen exists in cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function has(string $key): bool
+ {
+ return $this->cacheManager->has($key);
+ }
+
+ /**
+ * Check if screen is missing
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function missing(string $key): bool
+ {
+ return !$this->has($key);
+ }
+}

ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php

@@ -7,7 +7,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use ProcessMaker\Facades\ScreenCompiledManager;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\V1_1\TaskInterstitialResource;
 use ProcessMaker\Http\Resources\V1_1\TaskResource;
@@ -102,31 +102,43 @@ public function showScreen($taskId)
  $task = ProcessRequestToken::select(
  array_merge($this->defaultFields, ['process_request_id', 'process_id'])
  )
- // eager loading process_request.process_version_id
  ->with([
- 'processRequest'=> function ($query) {
+ 'processRequest'=> function ($query) {
  $query->select('id', 'process_version_id');
  },
  ])->findOrFail($taskId);
 
- // Prepare the key for the screen cache
+ // Get screen version and prepare cache key
  $processId = $task->process_id;
  $processVersionId = $task->processRequest->process_version_id;
  $language = TranslationManager::getTargetLanguage();
  $screenVersion = $task->getScreenVersion();
- $key = ScreenCompiledManager::createKey($processId, $processVersionId, $language, $screenVersion->screen_id, $screenVersion->id);
 
- // Get the screen content from the cache or compile it
- $translatedScreen = ScreenCompiledManager::getCompiledContent($key);
- if (!isset($translatedScreen)) {
+ // Get the appropriate cache handler based on configuration
+ $screenCache = ScreenCacheFactory::create();
+
+ // Create cache key
+ $key = $screenCache->createKey(
+ (int) $processId,
+ (int) $processVersionId,
+ $language,
+ (int) $screenVersion->screen_id,
+ (int) $screenVersion->id
+ );
+
+ // Try to get the screen from cache
+ $translatedScreen = $screenCache->get($key);
+
+ if ($translatedScreen === null) {
+ // If not in cache, create new response
  $response = new TaskScreen($task);
  $translatedScreen = $response->toArray(request())['screen'];
- ScreenCompiledManager::storeCompiledContent($key, $translatedScreen);
- }
 
- $response = response($translatedScreen, 200);
+ // Store in cache
+ $screenCache->set($key, $translatedScreen);
+ }
 
- return $response;
+ return response($translatedScreen, 200);
  }
 
  public function showInterstitial($taskId)

config/screens.php

@@ -0,0 +1,23 @@
+<?php
+
+return [
+ /*
+ |--------------------------------------------------------------------------
+ | Screen Cache Configuration
+ |--------------------------------------------------------------------------
+ |
+ | Here you can configure the screen caching behavior.
+ |
+ */
+
+ 'cache' => [
+ // Cache manager to use: 'new' for ScreenCacheManager, 'legacy' for ScreenCompiledManager
+ 'manager' => env('SCREEN_CACHE_MANAGER', 'legacy'),
+
+ // Cache driver to use (redis, file)
+ 'driver' => env('SCREEN_CACHE_DRIVER', 'file'),
+
+ // Default TTL for cached screens (24 hours)
+ 'ttl' => env('SCREEN_CACHE_TTL', 86400),
+ ],
+];

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class LegacyScreenCacheAdapter implements ScreenCacheInterface
+{
+ protected ScreenCompiledManager $compiledManager;
+
+ public function __construct(ScreenCompiledManager $compiledManager)
+ {
+ $this->compiledManager = $compiledManager;
+ }
+
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return $this->compiledManager->createKey(
+ (string) $processId,
+ (string) $processVersionId,
+ $language,
+ (string) $screenId,
+ (string) $screenVersionId
+ );
+ }
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $content = $this->compiledManager->getCompiledContent($key);
+
+ return $content ?? $default;
+ }
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool
+ {
+ $this->compiledManager->storeCompiledContent($key, $value);
+
+ return true;
+ }
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool
+ {
+ return $this->compiledManager->getCompiledContent($key) !== null;
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFacade.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * Class ScreenCacheFacade
+ *
+ * @mixin \ProcessMaker\Cache\Settings\ScreenCacheManager
+ */
+class ScreenCacheFacade extends Facade
+{
+ protected static function getFacadeAccessor()
+ {
+ return 'screen.cache';
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheFactory
+{
+ private static ?ScreenCacheInterface $testInstance = null;
+
+ /**
+ * Set a test instance for the factory
+ *
+ * @param ScreenCacheInterface|null $instance
+ */
+ public static function setTestInstance(?ScreenCacheInterface $instance): void
+ {
+ self::$testInstance = $instance;
+ }
+
+ /**
+ * Create a screen cache handler based on configuration
+ *
+ * @return ScreenCacheInterface
+ */
+ public static function create(): ScreenCacheInterface
+ {
+ if (self::$testInstance !== null) {
+ return self::$testInstance;
+ }
+
+ $manager = Config::get('screens.cache.manager', 'legacy');
+
+ if ($manager === 'new') {
+ return app(ScreenCacheManager::class);
+ }
+
+ // Get the concrete ScreenCompiledManager instance from the container
+ $compiledManager = app()->make(ScreenCompiledManager::class);
+
+ return new LegacyScreenCacheAdapter($compiledManager);
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+interface ScreenCacheInterface
+{
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed;
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool;
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool;
+}

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+{
+ protected CacheManager $cacheManager;
+
+ protected ScreenCompiledManager $screenCompiler;
+
+ /**
+ * Default TTL for cached screens (24 hours)
+ */
+ protected const DEFAULT_TTL = 86400;
+
+ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $screenCompiler)
+ {
+ $this->cacheManager = $cacheManager;
+ $this->screenCompiler = $screenCompiler;
+ }
+
+ /**
+ * Create a cache key for a screen
+ *
+ * @param int $processId Process ID
+ * @param int $processVersionId Process version ID
+ * @param string $language Language code
+ * @param int $screenId Screen ID
+ * @param int $screenVersionId Screen version ID
+ * @return string Cache key
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+ }
+
+ /**
+ * Get a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $default Default value
+ * @return mixed
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $serializedContent = $this->cacheManager->get($key);
+ if ($serializedContent !== null) {
+ return unserialize($serializedContent);
+ }
+
+ return $default;
+ }
+
+ /**
+ * Store a screen in memory cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $value Compiled screen content
+ * @param null|int|\DateInterval $ttl Time to live
+ * @return bool
+ */
+ public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+ {
+ $serializedContent = serialize($value);
+
+ return $this->cacheManager->put($key, $serializedContent, $ttl ?? self::DEFAULT_TTL);
+ }
+
+ /**
+ * Delete a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function delete(string $key): bool
+ {
+ return $this->cacheManager->forget($key);
+ }
+
+ /**
+ * Clear all screen caches
+ *
+ * @return bool
+ */
+ public function clear(): bool
+ {
+ return $this->cacheManager->flush();
+ }
+
+ /**
+ * Check if screen exists in cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function has(string $key): bool
+ {
+ return $this->cacheManager->has($key);
+ }
+
+ /**
+ * Check if screen is missing
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function missing(string $key): bool
+ {
+ return !$this->has($key);
+ }
+}

ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php

@@ -7,7 +7,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use ProcessMaker\Facades\ScreenCompiledManager;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\V1_1\TaskInterstitialResource;
 use ProcessMaker\Http\Resources\V1_1\TaskResource;
@@ -102,31 +102,43 @@ public function showScreen($taskId)
  $task = ProcessRequestToken::select(
  array_merge($this->defaultFields, ['process_request_id', 'process_id'])
  )
- // eager loading process_request.process_version_id
  ->with([
- 'processRequest'=> function ($query) {
+ 'processRequest'=> function ($query) {
  $query->select('id', 'process_version_id');
  },
  ])->findOrFail($taskId);
 
- // Prepare the key for the screen cache
+ // Get screen version and prepare cache key
  $processId = $task->process_id;
  $processVersionId = $task->processRequest->process_version_id;
  $language = TranslationManager::getTargetLanguage();
  $screenVersion = $task->getScreenVersion();
- $key = ScreenCompiledManager::createKey($processId, $processVersionId, $language, $screenVersion->screen_id, $screenVersion->id);
 
- // Get the screen content from the cache or compile it
- $translatedScreen = ScreenCompiledManager::getCompiledContent($key);
- if (!isset($translatedScreen)) {
+ // Get the appropriate cache handler based on configuration
+ $screenCache = ScreenCacheFactory::create();
+
+ // Create cache key
+ $key = $screenCache->createKey(
+ (int) $processId,
+ (int) $processVersionId,
+ $language,
+ (int) $screenVersion->screen_id,
+ (int) $screenVersion->id
+ );
+
+ // Try to get the screen from cache
+ $translatedScreen = $screenCache->get($key);
+
+ if ($translatedScreen === null) {
+ // If not in cache, create new response
  $response = new TaskScreen($task);
  $translatedScreen = $response->toArray(request())['screen'];
- ScreenCompiledManager::storeCompiledContent($key, $translatedScreen);
- }
 
- $response = response($translatedScreen, 200);
+ // Store in cache
+ $screenCache->set($key, $translatedScreen);
+ }
 
- return $response;
+ return response($translatedScreen, 200);
  }
 
  public function showInterstitial($taskId)

config/screens.php

@@ -0,0 +1,23 @@
+<?php
+
+return [
+ /*
+ |--------------------------------------------------------------------------
+ | Screen Cache Configuration
+ |--------------------------------------------------------------------------
+ |
+ | Here you can configure the screen caching behavior.
+ |
+ */
+
+ 'cache' => [
+ // Cache manager to use: 'new' for ScreenCacheManager, 'legacy' for ScreenCompiledManager
+ 'manager' => env('SCREEN_CACHE_MANAGER', 'legacy'),
+
+ // Cache driver to use (redis, file)
+ 'driver' => env('SCREEN_CACHE_DRIVER', 'file'),
+
+ // Default TTL for cached screens (24 hours)
+ 'ttl' => env('SCREEN_CACHE_TTL', 86400),
+ ],
+];

ProcessMaker/Cache/Screens/LegacyScreenCacheAdapter.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class LegacyScreenCacheAdapter implements ScreenCacheInterface
+{
+ protected ScreenCompiledManager $compiledManager;
+
+ public function __construct(ScreenCompiledManager $compiledManager)
+ {
+ $this->compiledManager = $compiledManager;
+ }
+
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return $this->compiledManager->createKey(
+ (string) $processId,
+ (string) $processVersionId,
+ $language,
+ (string) $screenId,
+ (string) $screenVersionId
+ );
+ }
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $content = $this->compiledManager->getCompiledContent($key);
+
+ return $content ?? $default;
+ }
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool
+ {
+ $this->compiledManager->storeCompiledContent($key, $value);
+
+ return true;
+ }
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool
+ {
+ return $this->compiledManager->getCompiledContent($key) !== null;
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFacade.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Facade;
+
+/**
+ * Class ScreenCacheFacade
+ *
+ * @mixin \ProcessMaker\Cache\Settings\ScreenCacheManager
+ */
+class ScreenCacheFacade extends Facade
+{
+ protected static function getFacadeAccessor()
+ {
+ return 'screen.cache';
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheFactory.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Support\Facades\Config;
+use ProcessMaker\Cache\Screens\ScreenCacheManager;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheFactory
+{
+ private static ?ScreenCacheInterface $testInstance = null;
+
+ /**
+ * Set a test instance for the factory
+ *
+ * @param ScreenCacheInterface|null $instance
+ */
+ public static function setTestInstance(?ScreenCacheInterface $instance): void
+ {
+ self::$testInstance = $instance;
+ }
+
+ /**
+ * Create a screen cache handler based on configuration
+ *
+ * @return ScreenCacheInterface
+ */
+ public static function create(): ScreenCacheInterface
+ {
+ if (self::$testInstance !== null) {
+ return self::$testInstance;
+ }
+
+ $manager = Config::get('screens.cache.manager', 'legacy');
+
+ if ($manager === 'new') {
+ return app(ScreenCacheManager::class);
+ }
+
+ // Get the concrete ScreenCompiledManager instance from the container
+ $compiledManager = app()->make(ScreenCompiledManager::class);
+
+ return new LegacyScreenCacheAdapter($compiledManager);
+ }
+}

ProcessMaker/Cache/Screens/ScreenCacheInterface.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+interface ScreenCacheInterface
+{
+ /**
+ * Create a cache key for a screen
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string;
+
+ /**
+ * Get a screen from cache
+ */
+ public function get(string $key, mixed $default = null): mixed;
+
+ /**
+ * Store a screen in cache
+ */
+ public function set(string $key, mixed $value): bool;
+
+ /**
+ * Check if screen exists in cache
+ */
+ public function has(string $key): bool;
+}

ProcessMaker/Cache/Screens/ScreenCacheManager.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace ProcessMaker\Cache\Screens;
+
+use Illuminate\Cache\CacheManager;
+use ProcessMaker\Cache\CacheInterface;
+use ProcessMaker\Managers\ScreenCompiledManager;
+
+class ScreenCacheManager implements CacheInterface, ScreenCacheInterface
+{
+ protected CacheManager $cacheManager;
+
+ protected ScreenCompiledManager $screenCompiler;
+
+ /**
+ * Default TTL for cached screens (24 hours)
+ */
+ protected const DEFAULT_TTL = 86400;
+
+ public function __construct(CacheManager $cacheManager, ScreenCompiledManager $screenCompiler)
+ {
+ $this->cacheManager = $cacheManager;
+ $this->screenCompiler = $screenCompiler;
+ }
+
+ /**
+ * Create a cache key for a screen
+ *
+ * @param int $processId Process ID
+ * @param int $processVersionId Process version ID
+ * @param string $language Language code
+ * @param int $screenId Screen ID
+ * @param int $screenVersionId Screen version ID
+ * @return string Cache key
+ */
+ public function createKey(int $processId, int $processVersionId, string $language, int $screenId, int $screenVersionId): string
+ {
+ return "pid_{$processId}_{$processVersionId}_{$language}_sid_{$screenId}_{$screenVersionId}";
+ }
+
+ /**
+ * Get a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $default Default value
+ * @return mixed
+ */
+ public function get(string $key, mixed $default = null): mixed
+ {
+ $serializedContent = $this->cacheManager->get($key);
+ if ($serializedContent !== null) {
+ return unserialize($serializedContent);
+ }
+
+ return $default;
+ }
+
+ /**
+ * Store a screen in memory cache
+ *
+ * @param string $key Screen cache key
+ * @param mixed $value Compiled screen content
+ * @param null|int|\DateInterval $ttl Time to live
+ * @return bool
+ */
+ public function set(string $key, mixed $value, null|int|\DateInterval $ttl = null): bool
+ {
+ $serializedContent = serialize($value);
+
+ return $this->cacheManager->put($key, $serializedContent, $ttl ?? self::DEFAULT_TTL);
+ }
+
+ /**
+ * Delete a screen from cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function delete(string $key): bool
+ {
+ return $this->cacheManager->forget($key);
+ }
+
+ /**
+ * Clear all screen caches
+ *
+ * @return bool
+ */
+ public function clear(): bool
+ {
+ return $this->cacheManager->flush();
+ }
+
+ /**
+ * Check if screen exists in cache
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function has(string $key): bool
+ {
+ return $this->cacheManager->has($key);
+ }
+
+ /**
+ * Check if screen is missing
+ *
+ * @param string $key Screen cache key
+ * @return bool
+ */
+ public function missing(string $key): bool
+ {
+ return !$this->has($key);
+ }
+}

ProcessMaker/Http/Controllers/Api/V1_1/TaskController.php

@@ -7,7 +7,7 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use ProcessMaker\Facades\ScreenCompiledManager;
+use ProcessMaker\Cache\Screens\ScreenCacheFactory;
 use ProcessMaker\Http\Controllers\Controller;
 use ProcessMaker\Http\Resources\V1_1\TaskInterstitialResource;
 use ProcessMaker\Http\Resources\V1_1\TaskResource;
@@ -102,31 +102,43 @@ public function showScreen($taskId)
  $task = ProcessRequestToken::select(
  array_merge($this->defaultFields, ['process_request_id', 'process_id'])
  )
- // eager loading process_request.process_version_id
  ->with([
- 'processRequest'=> function ($query) {
+ 'processRequest'=> function ($query) {
  $query->select('id', 'process_version_id');
  },
  ])->findOrFail($taskId);
 
- // Prepare the key for the screen cache
+ // Get screen version and prepare cache key
  $processId = $task->process_id;
  $processVersionId = $task->processRequest->process_version_id;
  $language = TranslationManager::getTargetLanguage();
  $screenVersion = $task->getScreenVersion();
- $key = ScreenCompiledManager::createKey($processId, $processVersionId, $language, $screenVersion->screen_id, $screenVersion->id);
 
- // Get the screen content from the cache or compile it
- $translatedScreen = ScreenCompiledManager::getCompiledContent($key);
- if (!isset($translatedScreen)) {
+ // Get the appropriate cache handler based on configuration
+ $screenCache = ScreenCacheFactory::create();
+
+ // Create cache key
+ $key = $screenCache->createKey(
+ (int) $processId,
+ (int) $processVersionId,
+ $language,
+ (int) $screenVersion->screen_id,
+ (int) $screenVersion->id
+ );
+
+ // Try to get the screen from cache
+ $translatedScreen = $screenCache->get($key);
+
+ if ($translatedScreen === null) {
+ // If not in cache, create new response
  $response = new TaskScreen($task);
  $translatedScreen = $response->toArray(request())['screen'];
- ScreenCompiledManager::storeCompiledContent($key, $translatedScreen);
- }
 
- $response = response($translatedScreen, 200);
+ // Store in cache
+ $screenCache->set($key, $translatedScreen);
+ }
 
- return $response;
+ return response($translatedScreen, 200);
  }
 
  public function showInterstitial($taskId)

config/screens.php

@@ -0,0 +1,23 @@
+<?php
+
+return [
+ /*
+ |--------------------------------------------------------------------------
+ | Screen Cache Configuration
+ |--------------------------------------------------------------------------
+ |
+ | Here you can configure the screen caching behavior.
+ |
+ */
+
+ 'cache' => [
+ // Cache manager to use: 'new' for ScreenCacheManager, 'legacy' for ScreenCompiledManager
+ 'manager' => env('SCREEN_CACHE_MANAGER', 'legacy'),
+
+ // Cache driver to use (redis, file)
+ 'driver' => env('SCREEN_CACHE_DRIVER', 'file'),
+
+ // Default TTL for cached screens (24 hours)
+ 'ttl' => env('SCREEN_CACHE_TTL', 86400),
+ ],
+];