@pwrdrvr/microapps-router-lib 0.4.0-alpha.8 → 0.4.0-alpha.9

package/src/app-cache.ts

@@ -0,0 +1,193 @@
+import { Application, DBManager, Rules, Version } from '@pwrdrvr/microapps-datalib';
+
+interface ICacheEntry<T> {
+  timestamp: number;
+  data: T;
+}
+
+export class AppVersionCache {
+  private negativeAppNameCache: Map<string, ICacheEntry<undefined>>;
+  private appRulesCache: Map<string, ICacheEntry<Rules>>;
+  private appVersionsCache: Map<string, Map<string, ICacheEntry<Version>>>;
+  private dbManager: DBManager;
+
+  private static instance: AppVersionCache;
+
+  /**
+   * Get the AppVersionCache instance or create it
+   */
+  public static GetInstance({ dbManager }: { dbManager: DBManager }): AppVersionCache {
+    if (!AppVersionCache.instance) {
+      AppVersionCache.instance = new AppVersionCache({ dbManager });
+    }
+
+    return AppVersionCache.instance;
+  }
+
+  constructor({ dbManager }: { dbManager: DBManager }) {
+    this.negativeAppNameCache = new Map();
+    this.appRulesCache = new Map();
+    this.appVersionsCache = new Map();
+    this.dbManager = dbManager;
+  }
+
+  private get CacheIsEmpty(): boolean {
+    return this.appRulesCache.size === 0 && this.appVersionsCache.size === 0;
+  }
+
+  /**
+   * Used to populate the cache when the cache is completely empty
+   * @param appName
+   */
+  private async PopulateEmptyCache({
+    key: { AppName },
+  }: {
+    key: { AppName: string };
+  }): Promise<void> {
+    const versionsAndRules = await Application.GetVersionsAndRules({
+      dbManager: this.dbManager,
+      key: { AppName },
+    });
+
+    if (!versionsAndRules || (versionsAndRules.Versions.length === 0 && !versionsAndRules.Rules)) {
+      this.negativeAppNameCache.set(AppName.toLowerCase(), {
+        timestamp: Date.now(),
+        data: undefined,
+      });
+      return;
+    }
+
+    // Remove negative cache entry if it exists
+    this.negativeAppNameCache.delete(AppName.toLowerCase());
+
+    this.appRulesCache.set(AppName.toLowerCase(), {
+      timestamp: Date.now(),
+      data: versionsAndRules.Rules,
+    });
+
+    const versionsMap = new Map<string, ICacheEntry<Version>>();
+    for (const version of versionsAndRules.Versions) {
+      versionsMap.set(version.SemVer, {
+        timestamp: Date.now(),
+        data: version,
+      });
+    }
+    this.appVersionsCache.set(AppName.toLowerCase(), versionsMap);
+  }
+
+  public ClearCache(): void {
+    this.appRulesCache.clear();
+    this.appVersionsCache.clear();
+  }
+
+  /**
+   * Get Rules for an app
+   *
+   * Populates the cache if empty
+   * Freshens a cache entry if it is stale
+   * Feturns the cached value if it is fresh
+   * Fetches a single item if the cache is not empty but the item is not in the cache
+   *
+   * @param appName
+   * @returns
+   */
+  public async GetRules({
+    key: { AppName },
+  }: {
+    key: { AppName: string };
+  }): Promise<Rules | undefined> {
+    const now = Date.now();
+
+    // Check the negative cache first
+    const negativeCacheEntry = this.negativeAppNameCache.get(AppName.toLowerCase());
+    if (negativeCacheEntry && now - negativeCacheEntry.timestamp < 60000) {
+      return undefined;
+    } else if (negativeCacheEntry) {
+      this.negativeAppNameCache.delete(AppName.toLowerCase());
+    }
+
+    const ruleCacheEntry = this.appRulesCache.get(AppName.toLowerCase());
+    if (ruleCacheEntry && now - ruleCacheEntry.timestamp < 60000) {
+      return ruleCacheEntry.data;
+    }
+
+    if (this.CacheIsEmpty || !ruleCacheEntry) {
+      await this.PopulateEmptyCache({ key: { AppName } });
+
+      return this.appRulesCache.get(AppName.toLowerCase())?.data;
+    }
+
+    const versionsAndRules = await Application.GetVersionsAndRules({
+      dbManager: this.dbManager,
+      key: { AppName: AppName },
+    });
+    this.appRulesCache.set(AppName.toLowerCase(), { timestamp: now, data: versionsAndRules.Rules });
+
+    return versionsAndRules.Rules;
+  }
+
+  /**
+   * Get Version info for an app and semVer
+   *
+   * Populates the cache if empty
+   * Freshens a cache entry if it is stale
+   * Feturns the cached value if it is fresh
+   * Fetches a single item if the cache is not empty but the item is not in the cache
+   *
+   * @param appName
+   * @returns
+   */
+  public async GetVersionInfo({
+    key: { AppName, SemVer },
+  }: {
+    key: { AppName: string; SemVer: string };
+  }): Promise<Version | undefined> {
+    const now = Date.now();
+
+    // Check the negative cache first
+    const negativeCacheEntry = this.negativeAppNameCache.get(AppName.toLowerCase());
+    if (negativeCacheEntry && now - negativeCacheEntry.timestamp < 60000) {
+      return undefined;
+    } else if (negativeCacheEntry) {
+      this.negativeAppNameCache.delete(AppName.toLowerCase());
+    }
+
+    // Check if we have the item cached and if it is fresh enough
+    const versionCacheEntry = this.appVersionsCache.get(AppName.toLowerCase());
+    if (versionCacheEntry) {
+      const versionInfo = versionCacheEntry.get(SemVer);
+      if (versionInfo && now - versionInfo.timestamp < 900000) {
+        return versionInfo.data;
+      }
+    }
+
+    if (this.CacheIsEmpty || !versionCacheEntry) {
+      await this.PopulateEmptyCache({ key: { AppName } });
+      if (!this.appVersionsCache) {
+        return undefined;
+      }
+
+      return this.appVersionsCache.get(AppName.toLowerCase())?.get(SemVer)?.data;
+    } else {
+      // We have some data in the cache, but not for this version
+      // So we need to get the data for this version
+      const versionInfo = await Version.LoadVersion({
+        dbManager: this.dbManager,
+        key: { AppName, SemVer: SemVer },
+      });
+      if (!versionInfo) {
+        return undefined;
+      }
+
+      const versionsMap = this.appVersionsCache.get(AppName.toLowerCase());
+      if (!versionsMap) {
+        return undefined;
+      }
+
+      // Save the version info in the cache
+      versionsMap.set(SemVer, { timestamp: now, data: versionInfo });
+
+      return versionInfo;
+    }
+  }
+}

package/src/index.spec.ts

@@ -97,7 +97,7 @@ describe('router - without prefix', () => {
     const version = new Version({
       AppName: 'Bat',
       IntegrationID: 'abcd',
-      SemVer: '3.2.1-beta.1',
+      SemVer: '3.2.1-beta.2',
       Status: 'deployed',
       Type: 'static',
     });
@@ -106,17 +106,17 @@ describe('router - without prefix', () => {
     const rules = new Rules({
       AppName: 'Bat',
       Version: 0,
-      RuleSet: { default: { SemVer: '3.2.1-beta.1', AttributeName: '', AttributeValue: '' } },
+      RuleSet: { default: { SemVer: '3.2.1-beta.2', AttributeName: '', AttributeValue: '' } },
     });
     await rules.Save(dbManager);
 
     // Call the handler
-    const response = await GetRoute({ dbManager, rawPath: '/bat/3.2.1-beta.1/' });
+    const response = await GetRoute({ dbManager, rawPath: '/bat/3.2.1-beta.2/' });
 
     expect(response).toHaveProperty('appName');
     expect(response.appName).toBe('bat');
     expect(response).toHaveProperty('semVer');
-    expect(response.semVer).toBe('3.2.1-beta.1');
+    expect(response.semVer).toBe('3.2.1-beta.2');
   });
 
   it('static app - request to app/x.y.z/ should redirect to defaultFile', async () => {
@@ -153,14 +153,15 @@ describe('router - without prefix', () => {
   });
 
   it('static app - request to app/notVersion should load app frame with defaultFile', async () => {
+    const AppName = 'Bat123';
     const app = new Application({
-      AppName: 'Bat',
+      AppName,
       DisplayName: 'Bat App',
     });
     await app.Save(dbManager);
 
     const version = new Version({
-      AppName: 'Bat',
+      AppName,
       DefaultFile: 'bat.html',
       IntegrationID: 'abcd',
       SemVer: '3.2.1-beta.1',
@@ -170,30 +171,31 @@ describe('router - without prefix', () => {
     await version.Save(dbManager);
 
     const rules = new Rules({
-      AppName: 'Bat',
+      AppName,
       Version: 0,
       RuleSet: { default: { SemVer: '3.2.1-beta.1', AttributeName: '', AttributeValue: '' } },
     });
     await rules.Save(dbManager);
 
     // Call the handler
-    const response = await GetRoute({ dbManager, rawPath: '/bat/notVersion' });
+    const response = await GetRoute({ dbManager, rawPath: `/${AppName}/notVersion` });
 
     expect(response).toHaveProperty('statusCode');
     expect(response.statusCode).toBe(200);
     expect(response).toBeDefined();
-    expect(response.iFrameAppVersionPath).toBe('/bat/3.2.1-beta.1/bat.html');
+    expect(response.iFrameAppVersionPath).toBe(`/${AppName}/3.2.1-beta.1/bat.html`);
   });
 
   it('should serve appframe with no default file', async () => {
+    const AppName = 'Bat124';
     const app = new Application({
-      AppName: 'Bat',
+      AppName,
       DisplayName: 'Bat App',
     });
     await app.Save(dbManager);
 
     const version = new Version({
-      AppName: 'Bat',
+      AppName,
       DefaultFile: '',
       IntegrationID: 'abcd',
       SemVer: '3.2.1-beta1',
@@ -203,30 +205,31 @@ describe('router - without prefix', () => {
     await version.Save(dbManager);
 
     const rules = new Rules({
-      AppName: 'Bat',
+      AppName,
       Version: 0,
       RuleSet: { default: { SemVer: '3.2.1-beta1', AttributeName: '', AttributeValue: '' } },
     });
     await rules.Save(dbManager);
 
     // Call the handler
-    const response = await GetRoute({ dbManager, rawPath: '/bat/' });
+    const response = await GetRoute({ dbManager, rawPath: `/${AppName}/` });
 
     expect(response).toBeDefined();
     expect(response).toHaveProperty('statusCode');
     expect(response.statusCode).toBe(200);
-    expect(response.iFrameAppVersionPath).toBe('/bat/3.2.1-beta1');
+    expect(response.iFrameAppVersionPath).toBe(`/${AppName}/3.2.1-beta1`);
   });
 
   it('should serve appframe with sub-route', async () => {
+    const AppName = 'Bat125';
     const app = new Application({
-      AppName: 'Bat',
+      AppName,
       DisplayName: 'Bat App',
     });
     await app.Save(dbManager);
 
     const version = new Version({
-      AppName: 'Bat',
+      AppName,
       DefaultFile: '',
       IntegrationID: 'abcd',
       SemVer: '3.2.1-beta2',
@@ -236,30 +239,31 @@ describe('router - without prefix', () => {
     await version.Save(dbManager);
 
     const rules = new Rules({
-      AppName: 'Bat',
+      AppName,
       Version: 0,
       RuleSet: { default: { SemVer: '3.2.1-beta2', AttributeName: '', AttributeValue: '' } },
     });
     await rules.Save(dbManager);
 
     // Call the handler
-    const response = await GetRoute({ dbManager, rawPath: '/bat/demo/grid' });
+    const response = await GetRoute({ dbManager, rawPath: `/${AppName}/demo/grid` });
 
     expect(response).toBeDefined();
     expect(response).toHaveProperty('statusCode');
     expect(response.statusCode).toBe(200);
-    expect(response.iFrameAppVersionPath).toBe('/bat/3.2.1-beta2/demo/grid');
+    expect(response.iFrameAppVersionPath).toBe(`/${AppName}/3.2.1-beta2/demo/grid`);
   });
 
   it('should serve appframe with sub-route', async () => {
+    const AppName = 'Bat126';
     const app = new Application({
-      AppName: 'Bat',
+      AppName,
       DisplayName: 'Bat App',
     });
     await app.Save(dbManager);
 
     const version = new Version({
-      AppName: 'Bat',
+      AppName,
       DefaultFile: 'someFile.html',
       IntegrationID: 'abcd',
       SemVer: '3.2.1-beta3',
@@ -269,19 +273,19 @@ describe('router - without prefix', () => {
     await version.Save(dbManager);
 
     const rules = new Rules({
-      AppName: 'Bat',
+      AppName,
       Version: 0,
       RuleSet: { default: { SemVer: '3.2.1-beta3', AttributeName: '', AttributeValue: '' } },
     });
     await rules.Save(dbManager);
 
     // Call the handler
-    const response = await GetRoute({ dbManager, rawPath: '/bat/demo' });
+    const response = await GetRoute({ dbManager, rawPath: `/${AppName}/demo` });
 
     expect(response).toBeDefined();
     expect(response).toHaveProperty('statusCode');
     expect(response.statusCode).toBe(200);
-    expect(response.iFrameAppVersionPath).toBe('/bat/3.2.1-beta3/demo');
+    expect(response.iFrameAppVersionPath).toBe(`/${AppName}/3.2.1-beta3/demo`);
   });
 
   it('should return 404 for /favicon.ico', async () => {

package/src/index.ts

@@ -1,12 +1,14 @@
-// Used by ts-convict
 import 'source-map-support/register';
 import path from 'path';
 import { pathExistsSync, readFileSync } from 'fs-extra';
-import { Application, DBManager, IVersionsAndRules, Version } from '@pwrdrvr/microapps-datalib';
+import { DBManager, Rules, Version } from '@pwrdrvr/microapps-datalib';
 import Log from './lib/log';
+import { AppVersionCache } from './app-cache';
 
 const log = Log.Instance;
 
+export { AppVersionCache };
+
 /**
  * Find and load the appFrame file
  * @returns
@@ -159,10 +161,13 @@ export async function GetRoute(event: IGetRouteEvent): Promise<IGetRouteResult>
     // /someapp/somepath/somefile.foo will split into length 4 with ["", "someapp", "somepath", "somefile.foo", ""] as results
     const partsAfterPrefix = pathAfterPrefix.split('/');
 
-    const { versionsAndRules, appName } = await GetAppInfo({
+    const appName = await GetAppInfo({
       dbManager,
       appName: partsAfterPrefix.length >= 2 ? partsAfterPrefix[1] : '[root]',
     });
+    if (!appName) {
+      return { statusCode: 404, errorMessage: 'App not found' };
+    }
 
     const isRootApp = appName === '[root]';
     const appNameOrRootTrailingSlash = isRootApp ? '' : `${appName}/`;
@@ -215,7 +220,7 @@ export async function GetRoute(event: IGetRouteEvent): Promise<IGetRouteResult>
     // ^  ^^^^^^^^^^^^
     // 0             1
     // Got at least an application name, try to route it
-    const response = RouteApp({
+    const response = await RouteApp({
       dbManager,
       normalizedPathPrefix,
       event,
@@ -224,7 +229,6 @@ export async function GetRoute(event: IGetRouteEvent): Promise<IGetRouteResult>
       possibleSemVerPathAfterApp,
       possibleSemVerQuery: queryStringParameters?.get('appver') || '',
       additionalParts,
-      versionsAndRules,
       appNameOrRootTrailingSlash,
     });
     if (response) {
@@ -244,44 +248,32 @@ export async function GetRoute(event: IGetRouteEvent): Promise<IGetRouteResult>
   }
 }
 
-export interface IAppInfo {
-  appName: string;
-  versionsAndRules: IVersionsAndRules;
-}
-
 /**
- * Get info about an app or the root app
+ * Determine if we have an appname or a catch all app
  */
 export async function GetAppInfo(opts: {
   dbManager: DBManager;
   appName: string;
-}): Promise<IAppInfo> {
+}): Promise<string | undefined> {
   const { dbManager, appName } = opts;
 
-  let versionsAndRules: IVersionsAndRules;
+  let rules: Rules | undefined;
 
-  versionsAndRules = await Application.GetVersionsAndRules({
-    dbManager,
-    key: { AppName: appName },
-  });
+  const appVersionCache = AppVersionCache.GetInstance({ dbManager });
 
-  if (versionsAndRules.Versions.length > 0) {
-    return {
-      appName,
-      versionsAndRules,
-    };
+  // Check if we got a matching app name
+  rules = await appVersionCache.GetRules({ key: { AppName: appName } });
+  if (rules && rules.AppName === appName.toLowerCase()) {
+    return appName;
   }
 
   // Check if we have a `[root]` app that is a catch all
-  versionsAndRules = await Application.GetVersionsAndRules({
-    dbManager,
-    key: { AppName: '[root]' },
-  });
+  rules = await appVersionCache.GetRules({ key: { AppName: '[root]' } });
+  if (rules && rules.AppName === '[root]') {
+    return '[root]';
+  }
 
-  return {
-    appName: '[root]',
-    versionsAndRules,
-  };
+  return undefined;
 }
 
 /**
@@ -293,7 +285,7 @@ export async function GetAppInfo(opts: {
  * @param log
  * @returns
  */
-function RouteApp(opts: {
+async function RouteApp(opts: {
   dbManager: DBManager;
   event: IGetRouteEvent;
   appName: string;
@@ -302,10 +294,10 @@ function RouteApp(opts: {
   possibleSemVerQuery?: string;
   additionalParts: string;
   normalizedPathPrefix?: string;
-  versionsAndRules: IVersionsAndRules;
   appNameOrRootTrailingSlash: string;
-}): IGetRouteResult {
+}): Promise<IGetRouteResult> {
   const {
+    dbManager,
     event,
     normalizedPathPrefix = '',
     appName,
@@ -313,21 +305,28 @@ function RouteApp(opts: {
     possibleSemVerPathAfterApp,
     possibleSemVerQuery,
     additionalParts,
-    versionsAndRules,
     appNameOrRootTrailingSlash,
   } = opts;
 
   let versionInfoToUse: Version | undefined;
 
+  const appVersionCache = AppVersionCache.GetInstance({ dbManager });
+
   // Check if the semver placeholder is actually a defined version
   const possibleSemVerPathAfterAppVersionInfo = possibleSemVerPathAfterApp
-    ? versionsAndRules.Versions.find((item) => item.SemVer === possibleSemVerPathAfterApp)
+    ? await appVersionCache.GetVersionInfo({
+        key: { AppName: appName, SemVer: possibleSemVerPathAfterApp },
+      })
     : undefined;
   const possibleSemVerPathNextDataVersionInfo = possibleSemVerPathNextData
-    ? versionsAndRules.Versions.find((item) => item.SemVer === possibleSemVerPathNextData)
+    ? await appVersionCache.GetVersionInfo({
+        key: { AppName: appName, SemVer: possibleSemVerPathNextData },
+      })
     : undefined;
   const possibleSemVerQueryVersionInfo = possibleSemVerQuery
-    ? versionsAndRules.Versions.find((item) => item.SemVer === possibleSemVerQuery)
+    ? await appVersionCache.GetVersionInfo({
+        key: { AppName: appName, SemVer: possibleSemVerQuery },
+      })
     : undefined;
 
   // If there is a version in the path, use it
@@ -377,7 +376,8 @@ function RouteApp(opts: {
     //     80% to 1.1.0, 20% to default (1.0.3)
     //
 
-    const defaultVersion = versionsAndRules.Rules?.RuleSet.default?.SemVer;
+    const rules = await appVersionCache.GetRules({ key: { AppName: appName } });
+    const defaultVersion = rules?.RuleSet.default?.SemVer;
 
     if (defaultVersion == null) {
       log.error(`could not find app ${appName}, for path ${event.rawPath} - returning 404`, {
@@ -390,10 +390,9 @@ function RouteApp(opts: {
       };
     }
 
-    // TODO: Yeah, this is lame - We should save these in a dictionary keyed by SemVer
-    const defaultVersionInfo = versionsAndRules.Versions.find(
-      (item) => item.SemVer === defaultVersion,
-    );
+    const defaultVersionInfo = await appVersionCache.GetVersionInfo({
+      key: { AppName: appName, SemVer: defaultVersion },
+    });
 
     versionInfoToUse = defaultVersionInfo;
   }
@@ -487,11 +486,13 @@ async function RedirectToDefaultFile(opts: {
     appNameOrRootTrailingSlash,
     semVer,
   } = opts;
-  let versionInfo: Version;
+  let versionInfo: Version | undefined;
 
   try {
-    versionInfo = await Version.LoadVersion({
-      dbManager,
+    // Get the cache
+    const appVersionCache = AppVersionCache.GetInstance({ dbManager });
+
+    versionInfo = await appVersionCache.GetVersionInfo({
       key: { AppName: appName, SemVer: semVer },
     });
   } catch (error) {