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

package/src/redirect-default-file.spec.ts

@@ -0,0 +1,98 @@
+import { DBManager, Version } from '@pwrdrvr/microapps-datalib';
+import { AppVersionCache } from './app-cache';
+import { RedirectToDefaultFile } from './redirect-default-file';
+
+jest.mock('./app-cache');
+
+describe('RedirectToDefaultFile', () => {
+  const mockDbManager = {} as DBManager;
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return undefined if GetVersionInfo throws an error', async () => {
+    (AppVersionCache.GetInstance as jest.Mock).mockImplementation(() => {
+      return {
+        GetVersionInfo: () => {
+          throw new Error('GetVersionInfo error');
+        },
+      };
+    });
+
+    const result = await RedirectToDefaultFile({
+      dbManager: mockDbManager,
+      appName: 'testApp',
+      semVer: '1.0.0',
+      appNameOrRootTrailingSlash: '',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined if versionInfo is undefined', async () => {
+    (AppVersionCache.GetInstance as jest.Mock).mockImplementation(() => {
+      return {
+        GetVersionInfo: () => undefined,
+      };
+    });
+
+    const result = await RedirectToDefaultFile({
+      dbManager: mockDbManager,
+      appName: 'testApp',
+      semVer: '1.0.0',
+      appNameOrRootTrailingSlash: '',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined if versionInfo.DefaultFile is not set', async () => {
+    const versionInfo: Version = {
+      AppName: 'testApp',
+      SemVer: '1.0.0',
+      // @ts-expect-error this is a test after-all
+      DefaultFile: undefined,
+    };
+    (AppVersionCache.GetInstance as jest.Mock).mockImplementation(() => {
+      return {
+        GetVersionInfo: () => versionInfo,
+      };
+    });
+
+    const result = await RedirectToDefaultFile({
+      dbManager: mockDbManager,
+      appName: 'testApp',
+      semVer: '1.0.0',
+      appNameOrRootTrailingSlash: '',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should return a redirect with status code 302 when versionInfo.DefaultFile is set', async () => {
+    // @ts-expect-error This is ok to be incomplete for the test
+    const versionInfo: Version = {
+      AppName: 'testApp',
+      SemVer: '1.0.0',
+      DefaultFile: 'index.html',
+    };
+    (AppVersionCache.GetInstance as jest.Mock).mockImplementation(() => {
+      return {
+        GetVersionInfo: () => versionInfo,
+      };
+    });
+
+    const result = await RedirectToDefaultFile({
+      dbManager: mockDbManager,
+      appName: 'testApp',
+      semVer: '1.0.0',
+      appNameOrRootTrailingSlash: 'testapp/',
+    });
+
+    expect(result).toEqual({
+      statusCode: 302,
+      redirectLocation: '/testapp/1.0.0/index.html',
+    });
+  });
+});

package/src/redirect-default-file.ts

@@ -0,0 +1,79 @@
+import { DBManager, Version } from '@pwrdrvr/microapps-datalib';
+import { AppVersionCache } from './app-cache';
+import { IGetRouteResult } from './get-route';
+import Log from './lib/log';
+
+const log = Log.Instance;
+
+/**
+ * Redirect the request to app/x.y.z/? to app/x.y.z/{defaultFile}
+ * @param response
+ * @param normalizedPathPrefix
+ * @param appName
+ * @param semVer
+ * @returns
+ */
+
+export async function RedirectToDefaultFile(opts: {
+  dbManager: DBManager;
+  normalizedPathPrefix?: string;
+  appName: string;
+  semVer: string;
+  appNameOrRootTrailingSlash: string;
+}): Promise<IGetRouteResult | undefined> {
+  const {
+    dbManager,
+    normalizedPathPrefix = '',
+    appName,
+    appNameOrRootTrailingSlash,
+    semVer,
+  } = opts;
+  let versionInfo: Version | undefined;
+
+  try {
+    // Get the cache
+    const appVersionCache = AppVersionCache.GetInstance({ dbManager });
+
+    versionInfo = await appVersionCache.GetVersionInfo({
+      key: { AppName: appName, SemVer: semVer },
+    });
+  } catch (error) {
+    log.info(
+      `LoadVersion threw for '${normalizedPathPrefix}/${appNameOrRootTrailingSlash}${semVer}' - falling through to app routing'`,
+      {
+        appName,
+        semVer,
+        error,
+      },
+    );
+    return undefined;
+  }
+
+  if (versionInfo === undefined) {
+    log.info(
+      `LoadVersion returned undefined for '${normalizedPathPrefix}/${appNameOrRootTrailingSlash}${semVer}', assuming not found - falling through to app routing'`,
+      {
+        appName,
+        semVer,
+      },
+    );
+    return undefined;
+  }
+
+  if (!versionInfo.DefaultFile) {
+    return undefined;
+  }
+
+  log.info(
+    `found '${normalizedPathPrefix}/${appNameOrRootTrailingSlash}${semVer}' - returning 302 to ${normalizedPathPrefix}/${appNameOrRootTrailingSlash}${semVer}/${versionInfo.DefaultFile}`,
+    {
+      statusCode: 302,
+      routedPath: `${normalizedPathPrefix}/${appNameOrRootTrailingSlash}${semVer}/${versionInfo.DefaultFile}`,
+    },
+  );
+
+  return {
+    statusCode: 302,
+    redirectLocation: `${normalizedPathPrefix}/${appNameOrRootTrailingSlash}${semVer}/${versionInfo.DefaultFile}`,
+  };
+}

package/src/route-app.spec.ts

@@ -0,0 +1,128 @@
+import { DBManager } from '@pwrdrvr/microapps-datalib';
+import { AppVersionCache } from './app-cache';
+import { RouteApp } from './route-app';
+
+jest.mock('./app-cache');
+
+describe('RouteApp', () => {
+  const mockDbManager = {} as DBManager;
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const testCases = [
+    {
+      caseName: 'should route simple app with iframe startup and no versions specified',
+      possibleSemVerPathAfterAppVersionInfo: undefined,
+      possibleSemVerPathNextDataVersionInfo: undefined,
+      possibleSemVerQueryVersionInfo: undefined,
+      possibleSemVerQuery: undefined,
+      defaultVersion: '1.0.0',
+      expectedStatusCode: 200,
+      expectedAppName: 'testApp',
+      expectedSemVer: '1.0.0',
+      expectedStartupType: 'iframe',
+    },
+    {
+      caseName: 'uses the path specified version instead of the default version',
+      possibleSemVerPathAfterAppVersionInfo: {
+        SemVer: '1.0.1',
+        DefaultFile: 'index.html',
+        StartupType: 'iframe',
+      },
+      possibleSemVerPathNextDataVersionInfo: undefined,
+      possibleSemVerQueryVersionInfo: undefined,
+      possibleSemVerQuery: undefined,
+      defaultVersion: '1.0.0',
+      expectedStatusCode: 200,
+      expectedAppName: 'testApp',
+      expectedSemVer: '1.0.1',
+      expectedStartupType: undefined,
+    },
+    {
+      caseName: 'uses the query string specified version instead of the default version',
+      possibleSemVerPathAfterAppVersionInfo: undefined,
+      possibleSemVerPathNextDataVersionInfo: undefined,
+      possibleSemVerQueryVersionInfo: {
+        SemVer: '1.0.3',
+        DefaultFile: 'index.html',
+        StartupType: 'iframe',
+      },
+      possibleSemVerQuery: '1.0.3',
+      defaultVersion: '1.0.0',
+      expectedStatusCode: 200,
+      expectedAppName: 'testApp',
+      expectedSemVer: '1.0.3',
+      expectedStartupType: 'iframe',
+    },
+    {
+      caseName: 'gives a 404 when the query string version does not exist',
+      possibleSemVerPathAfterAppVersionInfo: undefined,
+      possibleSemVerPathNextDataVersionInfo: undefined,
+      possibleSemVerQueryVersionInfo: undefined,
+      possibleSemVerQuery: '1.0.4',
+      defaultVersion: '1.0.0',
+      expectedStatusCode: 404,
+      expectedAppName: undefined,
+      expectedSemVer: undefined,
+      expectedStartupType: undefined,
+    },
+  ];
+
+  it.each(testCases)(
+    '$caseName',
+    async ({
+      possibleSemVerPathAfterAppVersionInfo,
+      possibleSemVerPathNextDataVersionInfo,
+      possibleSemVerQueryVersionInfo,
+      possibleSemVerQuery,
+      defaultVersion,
+      expectedStatusCode,
+      expectedAppName,
+      expectedSemVer,
+      expectedStartupType,
+    }) => {
+      (AppVersionCache.GetInstance as jest.Mock).mockImplementation(() => {
+        return {
+          GetVersionInfo: (options: { key: { AppName: string; SemVer: string } }) => {
+            if (options.key.SemVer === 'pathAfterApp') {
+              return possibleSemVerPathAfterAppVersionInfo;
+            }
+            if (options.key.SemVer === 'pathNextData') {
+              return possibleSemVerPathNextDataVersionInfo;
+            }
+            if (options.key.SemVer === 'query') {
+              return possibleSemVerQueryVersionInfo;
+            }
+            if (options.key.SemVer === defaultVersion) {
+              return { ...options.key, DefaultFile: 'index.html', StartupType: 'iframe' };
+            }
+            return undefined;
+          },
+          GetRules: () => ({ RuleSet: { default: { SemVer: defaultVersion } } }),
+        };
+      });
+
+      const result = await RouteApp({
+        dbManager: mockDbManager,
+        event: { dbManager: mockDbManager, locales: [], rawPath: '/testApp' },
+        appName: 'testApp',
+        possibleSemVerPathNextData: possibleSemVerPathNextDataVersionInfo
+          ? 'pathNextData'
+          : undefined,
+        possibleSemVerPathAfterApp: possibleSemVerPathAfterAppVersionInfo
+          ? 'pathAfterApp'
+          : undefined,
+        possibleSemVerQuery: possibleSemVerQueryVersionInfo ? 'query' : possibleSemVerQuery,
+        additionalParts: '',
+        appNameOrRootTrailingSlash: '',
+      });
+
+      expect(result.statusCode).toBe(expectedStatusCode);
+      expect(result.appName).toBe(expectedAppName);
+      expect(result.semVer).toBe(expectedSemVer);
+      expect(result.startupType).toBe(expectedStartupType);
+    },
+  );
+});

package/src/route-app.ts

@@ -0,0 +1,202 @@
+import { DBManager, Version } from '@pwrdrvr/microapps-datalib';
+import { AppVersionCache } from './app-cache';
+import { IGetRouteEvent, IGetRouteResult } from './get-route';
+import Log from './lib/log';
+
+const log = Log.Instance;
+
+/**
+ * Lookup the version of the app to run
+ * @param event
+ * @param response
+ * @param appName
+ * @param additionalParts
+ * @param log
+ * @returns
+ */
+
+export async function RouteApp(opts: {
+  dbManager: DBManager;
+  event: IGetRouteEvent;
+  appName: string;
+  possibleSemVerPathNextData?: string;
+  possibleSemVerPathAfterApp?: string;
+  possibleSemVerQuery?: string;
+  additionalParts: string;
+  normalizedPathPrefix?: string;
+  appNameOrRootTrailingSlash: string;
+}): Promise<IGetRouteResult> {
+  const {
+    dbManager,
+    event,
+    normalizedPathPrefix = '',
+    appName,
+    possibleSemVerPathNextData,
+    possibleSemVerPathAfterApp,
+    possibleSemVerQuery,
+    additionalParts,
+    appNameOrRootTrailingSlash,
+  } = opts;
+
+  let versionInfoToUse: Version | undefined;
+
+  const appVersionCache = AppVersionCache.GetInstance({ dbManager });
+
+  // Check if the semver placeholder is actually a defined version
+  const possibleSemVerPathAfterAppVersionInfo = possibleSemVerPathAfterApp
+    ? await appVersionCache.GetVersionInfo({
+        key: { AppName: appName, SemVer: possibleSemVerPathAfterApp },
+      })
+    : undefined;
+  const possibleSemVerPathNextDataVersionInfo = possibleSemVerPathNextData
+    ? await appVersionCache.GetVersionInfo({
+        key: { AppName: appName, SemVer: possibleSemVerPathNextData },
+      })
+    : undefined;
+  const possibleSemVerQueryVersionInfo = possibleSemVerQuery
+    ? await appVersionCache.GetVersionInfo({
+        key: { AppName: appName, SemVer: possibleSemVerQuery },
+      })
+    : undefined;
+
+  // If there is a version in the path, use it
+  const possibleSemVerPathVersionInfo =
+    possibleSemVerPathAfterAppVersionInfo || possibleSemVerPathNextDataVersionInfo;
+  if (possibleSemVerPathVersionInfo) {
+    //
+    // If this is an iframe app then it's a startup request
+    // If this is a direct app then it's a regular request to send to the app
+    //
+    // This is a version, and it's in the path already, route the request to it
+    // without creating iframe
+    return {
+      statusCode: 200,
+      appName,
+      semVer: possibleSemVerPathVersionInfo.SemVer,
+      isAPIPath: additionalParts.startsWith('api/'),
+      ...(possibleSemVerPathVersionInfo?.URL ? { url: possibleSemVerPathVersionInfo?.URL } : {}),
+      ...(possibleSemVerPathVersionInfo?.Type
+        ? {
+            type:
+              possibleSemVerPathVersionInfo?.Type === 'lambda'
+                ? 'apigwy'
+                : possibleSemVerPathVersionInfo?.Type,
+          }
+        : {}),
+    };
+  } else if (possibleSemVerQueryVersionInfo) {
+    // We got a version for the query string, but it's not in the path,
+    // so fall back to normal routing (create an iframe or direct route)
+    versionInfoToUse = possibleSemVerQueryVersionInfo;
+  } else if (possibleSemVerQuery) {
+    // We got a version in the query string but it does not exist
+    // This needs to 404 as this is a very specific request for a specific version
+    log.error(`could not find app ${appName}, for path ${event.rawPath} - returning 404`, {
+      statusCode: 404,
+    });
+
+    return {
+      statusCode: 404,
+      errorMessage: `Router - Could not find app: ${event.rawPath}, ${appName}`,
+    };
+  } else {
+    //
+    // TODO: Get the incoming attributes of user
+    // For logged in users, these can be: department, product type,
+    //  employee, office, division, etc.
+    // For anonymous users this can be: geo region, language,
+    // browser, IP, CIDR, ASIN, etc.
+    //
+    // The Rules can be either a version or a distribution of versions,
+    // including default, for example:
+    //     80% to 1.1.0, 20% to default (1.0.3)
+    //
+    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`, {
+        statusCode: 404,
+      });
+
+      return {
+        statusCode: 404,
+        errorMessage: `Router - Could not find app: ${event.rawPath}, ${appName}`,
+      };
+    }
+
+    const defaultVersionInfo = await appVersionCache.GetVersionInfo({
+      key: { AppName: appName, SemVer: defaultVersion },
+    });
+
+    versionInfoToUse = defaultVersionInfo;
+  }
+
+  if (!versionInfoToUse) {
+    log.error(
+      `could not find version info for app ${appName}, for path ${event.rawPath} - returning 404`,
+      {
+        statusCode: 404,
+      },
+    );
+
+    return {
+      statusCode: 404,
+      errorMessage: `Router - Could not find version info for app: ${event.rawPath}, ${appName}`,
+    };
+  }
+
+  if (versionInfoToUse?.StartupType === 'iframe' || !versionInfoToUse?.StartupType) {
+    // Prepare the iframe contents
+    let appVersionPath: string;
+    if (
+      // versionInfoToUse?.Type !== 'static' &&
+      versionInfoToUse?.DefaultFile === undefined ||
+      versionInfoToUse?.DefaultFile === '' ||
+      additionalParts !== ''
+    ) {
+      // KLUDGE: We're going to take a missing default file to mean that the
+      // app type is Next.js (or similar) and that it wants no trailing slash after the version
+      // TODO: Move this to an attribute of the version
+      appVersionPath = `${normalizedPathPrefix}/${appNameOrRootTrailingSlash}${versionInfoToUse.SemVer}`;
+      if (additionalParts !== '') {
+        appVersionPath += `/${additionalParts}`;
+      }
+    } else {
+      // Linking to the file directly means this will be peeled off by the S3 route
+      // That means we won't have to proxy this from S3
+      appVersionPath = `${normalizedPathPrefix}/${appNameOrRootTrailingSlash}${versionInfoToUse.SemVer}/${versionInfoToUse.DefaultFile}`;
+    }
+
+    return {
+      statusCode: 200,
+      appName,
+      semVer: versionInfoToUse.SemVer,
+      startupType: 'iframe',
+      isAPIPath: additionalParts.startsWith('api/'),
+      ...(versionInfoToUse?.URL ? { url: versionInfoToUse?.URL } : {}),
+      ...(versionInfoToUse?.Type
+        ? { type: versionInfoToUse?.Type === 'lambda' ? 'apigwy' : versionInfoToUse?.Type }
+        : {}),
+      iFrameAppVersionPath: appVersionPath,
+    };
+  } else {
+    // This is a direct app version, no iframe needed
+    if (versionInfoToUse?.Type === 'lambda') {
+      throw new Error('Invalid type for direct app version');
+    }
+    if (['apigwy', 'static'].includes(versionInfoToUse?.Type || '')) {
+      throw new Error('Invalid type for direct app version');
+    }
+
+    return {
+      statusCode: 200,
+      appName,
+      semVer: versionInfoToUse.SemVer,
+      startupType: 'direct',
+      isAPIPath: additionalParts.startsWith('api/'),
+      ...(versionInfoToUse?.URL ? { url: versionInfoToUse?.URL } : {}),
+      ...(versionInfoToUse?.Type ? { type: versionInfoToUse?.Type } : {}),
+    };
+  }
+}