feat: memoize app getStatus calls

packages/apps-engine/src/server/AppManager.ts

@@ -36,6 +36,7 @@ import type { IAppStorageItem } from './storage';
 import { AppLogStorage, AppMetadataStorage } from './storage';
 import { AppSourceStorage } from './storage/AppSourceStorage';
 import { AppInstallationSource } from './storage/IAppStorageItem';
+import { AppStatusCache } from './AppStatusCache';
 
 export interface IAppInstallParameters {
     enable: boolean;
@@ -101,6 +102,8 @@ export class AppManager {
 
     private readonly runtime: AppRuntimeManager;
 
+    private readonly appStatusCache: AppStatusCache;
+
     private isLoaded: boolean;
 
     constructor({ metadataStorage, logStorage, bridges, sourceStorage }: IAppManagerDeps) {
@@ -137,6 +140,8 @@ export class AppManager {
 
         this.parser = new AppPackageParser();
         this.compiler = new AppCompiler();
+        this.appStatusCache = new AppStatusCache();
+
         this.accessorManager = new AppAccessorManager(this);
         this.listenerManager = new AppListenerManager(this);
         this.commandManager = new AppSlashCommandManager(this);
@@ -233,6 +238,10 @@ export class AppManager {
         return this.runtime;
     }
 
+    public getAppStatusCache(): AppStatusCache {
+        return this.appStatusCache;
+    }
+
     /** Gets whether the Apps have been loaded or not. */
     public areAppsLoaded(): boolean {
         return this.isLoaded;

packages/apps-engine/src/server/AppStatusCache.ts

@@ -0,0 +1,40 @@
+import type { AppStatus } from '../definition/AppStatus';
+
+export class AppStatusCache {
+    private readonly cache: Record<string, { status: AppStatus, expiresAt: Date }> = {};
+    private readonly CACHE_TTL = 1000 * 60;
+
+    // We clean up the cache every 5 minutes
+    private readonly CLEANUP_INTERVAL = 1000 * 60 * 5;
+
+    public constructor() {
+        setInterval(() => this.clearExpired(), this.CLEANUP_INTERVAL);
+    }
+
+    public set(appId: string, status: AppStatus): void {
+        this.cache[appId] = {
+            status,
+            expiresAt: new Date(Date.now() + this.CACHE_TTL),
+        };
+    }
+
+    public get(appId: string): AppStatus | undefined {
+        const cache = this.cache[appId];
+
+        if (cache && cache.expiresAt > new Date()) {
+            return cache.status;
+        }
+
+        return undefined;
+    }
+
+    private clearExpired(): void {
+        const now = new Date();
+
+        for (const appId in this.cache) {
+            if (this.cache[appId].expiresAt < now) {
+                delete this.cache[appId];
+            }
+        }
+    }
+}

packages/apps-engine/src/server/ProxiedApp.ts

@@ -84,7 +84,7 @@ export class ProxiedApp {
 
     public async setStatus(status: AppStatus, silent?: boolean): Promise<void> {
         await this.call(AppMethod.SETSTATUS, status);
-
+        this.manager.getAppStatusCache().set(this.getID(), status);
         if (!silent) {
             await this.manager.getBridges().getAppActivationBridge().doAppStatusChanged(this, status);
         }

packages/apps-engine/src/server/runtime/deno/AppsEngineDenoRuntime.ts

@@ -17,6 +17,7 @@ import type { IParseAppPackageResult } from '../../compiler';
 import { AppConsole, type ILoggerStorageEntry } from '../../logging';
 import type { AppAccessorManager, AppApiManager } from '../../managers';
 import type { AppLogStorage, IAppStorageItem } from '../../storage';
+import { AppStatusCache } from '../../AppStatusCache';
 
 const baseDebug = debugFactory('appsEngine:runtime:deno');
 
@@ -110,6 +111,8 @@ export class DenoRuntimeSubprocessController extends EventEmitter {
     private readonly messenger: ProcessMessenger;
 
     private readonly livenessManager: LivenessManager;
+
+    private readonly appStatusCache: AppStatusCache;
 
     // We need to keep the appSource around in case the Deno process needs to be restarted
     constructor(
@@ -133,6 +136,7 @@ export class DenoRuntimeSubprocessController extends EventEmitter {
         this.api = manager.getApiManager();
         this.logStorage = manager.getLogStorage();
         this.bridges = manager.getBridges();
+        this.appStatusCache = manager.getAppStatusCache();
     }
 
     public spawnProcess(): void {
@@ -241,7 +245,16 @@ export class DenoRuntimeSubprocessController extends EventEmitter {
             return AppStatus.UNKNOWN;
         }
 
-        return this.sendRequest({ method: 'app:getStatus', params: [] }) as Promise<AppStatus>;
+        const statusCache = this.appStatusCache.get(this.getAppId());
+        if (!statusCache) {
+            this.debug(`${this.getAppId()} status not found in cache, fetching from subprocess`);
+            const status = await this.sendRequest({ method: 'app:getStatus', params: [] }) as AppStatus;
+            this.appStatusCache.set(this.getAppId(), status);
+            return status;
+        }
+
+        this.debug(`${this.getAppId()} status found in cache: ${statusCache}`);
+        return statusCache;
     }
 
     public async setupApp() {

packages/apps-engine/tests/test-data/TestAppStatusCache.ts

@@ -0,0 +1,4 @@
+import { AppStatusCache } from '../../src/server/AppStatusCache';
+
+export class TestAppStatusCache extends AppStatusCache {
+}

packages/apps-engine/tests/test-data/utilities.ts

@@ -36,6 +36,7 @@ import type { AppRuntimeManager } from '../../src/server/managers/AppRuntimeMana
 import type { UIActionButtonManager } from '../../src/server/managers/UIActionButtonManager';
 import type { DenoRuntimeSubprocessController } from '../../src/server/runtime/deno/AppsEngineDenoRuntime';
 import type { AppLogStorage, AppMetadataStorage, AppSourceStorage, IAppStorageItem } from '../../src/server/storage';
+import { TestAppStatusCache } from './TestAppStatusCache';
 
 export class TestInfastructureSetup {
     private appStorage: TestsAppStorage;
@@ -103,6 +104,9 @@ export class TestInfastructureSetup {
             getRuntime: () => {
                 return this.runtimeManager;
             },
+            getAppStatusCache() {
+                return new TestAppStatusCache();
+            },
         } as unknown as AppManager;
     }