@jpmorganchase/mosaic-site-middleware 0.1.0-beta.9

package/src/session.ts

@@ -0,0 +1,131 @@
+import cookie from 'node-cookie';
+import decode from 'jwt-decode';
+import { Session, JWT } from '@jpmorganchase/mosaic-types';
+
+if (typeof window !== 'undefined') {
+  throw new Error('This file should not be loaded on the client.');
+}
+
+const cookieSecret = process.env.COOKIE_SECRET;
+const isCookieSecretSet = !!cookieSecret;
+const TOKEN_COOKIE_NAME = 'access_token';
+const DEFAULT_COOKIE_CONFIG = {
+  httpOnly: true,
+  secure: process.env.NODE_ENV !== 'development',
+  sameSite: 'lax',
+  path: '/'
+};
+
+export function getToken(req): string | null {
+  if (!req) {
+    return null;
+  }
+
+  if (req.headers.authorization?.startsWith('Bearer ')) {
+    return req.headers.authorization.split(' ')[1];
+  }
+
+  return cookie.get(req, TOKEN_COOKIE_NAME, cookieSecret, isCookieSecretSet);
+}
+
+export function getIsCypressSession(req): boolean {
+  if (!req) {
+    return false;
+  }
+
+  return Boolean(req.headers?.cypresse2e === 'true');
+}
+
+export function clearSession(res) {
+  if (!res) {
+    throw new Error('Cannot clear session - response object invalid');
+  }
+  return cookie.clear(res, TOKEN_COOKIE_NAME, DEFAULT_COOKIE_CONFIG);
+}
+
+export function isSessionAgeMoreThan(session: Session, minRemainingTime = 0) {
+  const { expires = 0 } = session;
+  return expires >= Date.now() + minRemainingTime;
+}
+
+// eslint-disable-next complexity
+export function getSessionFromToken(accessToken): Session | null {
+  try {
+    if (!accessToken) {
+      throw new Error('No token provided');
+    }
+
+    const decodedToken = decode(accessToken) as JWT;
+
+    if (!decodedToken) {
+      throw new Error('Invalid token');
+    }
+
+    const {
+      exp = -1,
+      UserID = '',
+      JPMCIdentifier = '',
+      UID = '',
+      EmployeeCorporateID = '',
+      CostCenter = '',
+      Country = '',
+      CountryCode = '',
+      Department = '',
+      DisplayName = '',
+      Email = '',
+      EmployeeType = '',
+      FirstName = '',
+      LastName = '',
+      LOB = '',
+      LocationCode = ''
+    } = decodedToken;
+    if (decodedToken) {
+      const expires = exp * 1000;
+
+      if (expires < Date.now()) {
+        return null;
+      }
+
+      const sid = UserID || JPMCIdentifier || UID || EmployeeCorporateID;
+      return {
+        expires,
+        isLoggedIn: true,
+        accessToken,
+        user: {
+          avatarUrl: process.env.AVATAR_URL!,
+          sid,
+          country: Country,
+          countryCode: CountryCode,
+          costCenter: CostCenter,
+          department: Department,
+          displayName: DisplayName,
+          email: Email,
+          employeeType: EmployeeType,
+          firstName: FirstName,
+          lastName: LastName,
+          lob: LOB,
+          locationCode: LocationCode
+        }
+      };
+    }
+    throw new Error('Could not decode token');
+  } catch (e) {
+    console.error(e);
+  }
+
+  return null;
+}
+
+export function createSession(res, accessToken, expires) {
+  return cookie.create(
+    res,
+    TOKEN_COOKIE_NAME,
+    accessToken,
+    {
+      ...DEFAULT_COOKIE_CONFIG,
+      maxAge: (expires - new Date().getTime()) / 1000
+    },
+    cookieSecret,
+    isCookieSecretSet
+  );
+}

package/src/withContent.ts

@@ -0,0 +1,67 @@
+import { compileMDX } from './compileMdx.js';
+import { MosaicMiddleware } from './createMiddlewareRunner.js';
+import MiddlewareError from './MiddlewareError.js';
+
+if (typeof window !== 'undefined') {
+  throw new Error('This file should not be loaded on the client.');
+}
+
+/**
+ *  [[`ContentProps`]] specifies the page source/content
+ */
+export interface ContentProps {
+  /** Page source, which will be page type specific */
+  source?: Record<string, unknown>;
+  /** Page type */
+  type?: string;
+  /** Raw page content, includes markdown and frontmatter */
+  raw?: string;
+}
+
+/**
+ * Adds the [[`ContentProps`]] object to the page props
+ * @param context
+ */
+export const withContent: MosaicMiddleware<ContentProps> = async context => {
+  if (context.res.getHeader('X-Mosaic-Mode') !== 'active') {
+    return {};
+  }
+
+  const { resolvedUrl } = context;
+  try {
+    const mosaicUrl = context.res.getHeader('X-Mosaic-Content-Url');
+    const req = await fetch(`${mosaicUrl}${resolvedUrl}`);
+
+    if (req.ok) {
+      const contentType = req.headers.get('content-type');
+      if (contentType && contentType.includes('/mdx')) {
+        const text = await req.text();
+        const mdxSource = await compileMDX(text);
+        return { props: { type: 'mdx', source: mdxSource, raw: text } };
+      }
+      if (contentType && contentType.includes('/json')) {
+        const json = await req.json();
+        return { props: { type: 'json', ...json } };
+      }
+      // If redirect url was returned
+    } else if (req.status === 302) {
+      return {
+        redirect: {
+          destination: (await req.json()).redirect,
+          permanent: true
+        }
+      };
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+      throw new MiddlewareError(500, resolvedUrl, [error.message], { show500: true });
+    } else {
+      console.error('unexpected error');
+      throw new MiddlewareError(500, resolvedUrl, ['unexpected error'], { show500: true });
+    }
+  }
+  throw new MiddlewareError(404, resolvedUrl, [`Could not find any content for ${resolvedUrl}`], {
+    show404: true
+  });
+};

package/src/withMosaicMode.ts

@@ -0,0 +1,26 @@
+import type { MosaicMode } from '@jpmorganchase/mosaic-types';
+
+import type { MosaicMiddleware } from './createMiddlewareRunner.js';
+
+if (typeof window !== 'undefined') {
+  throw new Error('This file should not be loaded on the client.');
+}
+
+/**
+ *  [[`MosaicModeProps`]] specifies the mode mosaic uses
+ */
+export interface MosaicModeProps {
+  mode?: MosaicMode;
+}
+
+/**
+ * Adds the [[`MosaicModeProps`]] object to the page props
+ * @param context
+ */
+export const withMosaicMode: MosaicMiddleware<MosaicModeProps> = async context => {
+  const mode: MosaicMode = (process.env.MOSAIC_MODE || 'active') as MosaicMode;
+  const mosaicContentUrl = process.env[`MOSAIC_${mode.toUpperCase()}_MODE_URL`] || '';
+  context.res.setHeader('X-Mosaic-Mode', mode);
+  context.res.setHeader('X-Mosaic-Content-Url', mosaicContentUrl);
+  return { props: { mode } };
+};

package/src/withSession.ts

@@ -0,0 +1,103 @@
+import { GetServerSidePropsContext } from 'next';
+import type { Session } from '@jpmorganchase/mosaic-types';
+
+import { getSessionFromToken, getToken, getIsCypressSession } from './session.js';
+import { MosaicMiddleware } from './createMiddlewareRunner.js';
+import MiddlewareError from './MiddlewareError.js';
+
+if (typeof window !== 'undefined') {
+  throw new Error('This file should not be loaded on the client.');
+}
+
+/**
+ *  [[`SessionProps`]] specifies session object containing user profile of logged in user
+ */
+export interface SessionProps {
+  session?: Session;
+}
+
+/**
+ *  [[`SessionOptions`]] specifies a configuration object for the withSession middleware
+ */
+export interface SessionOptions {
+  /** is login required for the environment */
+  loginRequired: boolean;
+}
+
+const getRedirectOptions = (context: GetServerSidePropsContext) => {
+  const url = new URL(
+    `${process.env.HOSTNAME?.replace(/\/$/, '')}/${context.resolvedUrl.replace(/^\//, '')}`
+  );
+
+  if (url.search.includes('code=')) {
+    throw new Error(
+      'Authorisation loop detected. `code` should never appear in the client query string.'
+    );
+  }
+  url.searchParams.delete('namespace');
+  url.searchParams.delete('slug');
+  return {
+    redirect: {
+      destination: `/api/auth/login?referrer=${encodeURIComponent(`${url.pathname}${url.search}`)}`,
+      permanent: false
+    }
+  };
+};
+
+async function resolveSession(accessToken) {
+  return (
+    accessToken &&
+    process.env.DISABLE_IDA_SERVICE_AUTH_TOKEN_VERIFICATION === 'true' &&
+    (getSessionFromToken(accessToken) as Session)
+  );
+}
+
+/**
+ * Adds the [[`Session`]] object to the page props
+ * @param context
+ * @param options
+ */
+export const withSession: MosaicMiddleware<SessionProps, SessionOptions> = async (
+  context,
+  options
+) => {
+  if (process.env.ENABLE_LOGIN !== 'true') {
+    return {};
+  }
+  if (!process.env.COOKIE_SECRET) {
+    const errorMessage = '`process.env.COOKIE_SECRET` must be set in environment variables.';
+    throw new MiddlewareError(500, context.resolvedUrl, [errorMessage], {
+      show500: true
+    });
+  }
+  const accessToken = getToken(context.req);
+  const isCypressSession = getIsCypressSession(context.req);
+  const session = await resolveSession(accessToken);
+  // Do the middleware options have `loginRequired` true?
+  const isRedirectEnabled = options?.loginRequired;
+  const isLoggedIn = !!(
+    accessToken &&
+    session &&
+    // If session remaining time is <15m we'll request a re-login
+    isSessionRemainingMoreThan(session, 900000 /* 15 mins */)
+  );
+  if (isRedirectEnabled && !isLoggedIn) {
+    return getRedirectOptions(context);
+  }
+
+  return {
+    props: {
+      session: {
+        ...session,
+        isLoggedIn,
+        accessToken,
+        isCypressSession
+      }
+    }
+  };
+};
+
+function isSessionRemainingMoreThan(session: Session, minRemainingTime = 1800000 /* 30 mins */) {
+  const { expires = 0 } = session;
+  return expires >= Date.now() + minRemainingTime;
+}

package/src/withSharedConfig.ts

@@ -0,0 +1,92 @@
+import path from 'path';
+import fs from 'fs';
+import { GetServerSidePropsContext } from 'next';
+import type { SharedConfig, SharedConfigSlice } from '@jpmorganchase/mosaic-store';
+import { MosaicMiddleware } from './createMiddlewareRunner.js';
+import MiddlewareError from './MiddlewareError.js';
+
+if (typeof window !== 'undefined') {
+  throw new Error('This file should not be loaded on the client.');
+}
+
+export { SharedConfig };
+
+/**
+ * Fetch from mosaic the shared-config.json.
+ *
+ * @param url the shared config file URL
+ * @returns shared config JSON
+ */
+async function fetchSharedConfig(url: string) {
+  const response = await fetch(url, {
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  });
+  return response;
+}
+
+/**
+ * Read from the file system the shared config
+ *
+ * @param url the shared config file URL
+ * @returns shared config JSON
+ */
+async function readSharedConfig(url: string) {
+  const mosaicSnapshotDir = process.env.MOSAIC_SNAPSHOT_DIR || '';
+  const filePath = path.posix.join(process.cwd(), mosaicSnapshotDir, url);
+  try {
+    const realPath = await fs.promises.realpath(filePath);
+    const data = await fs.promises.readFile(realPath, 'utf-8');
+    return new Response(data.toString(), { status: 200 });
+  } catch (e) {
+    // it doesn't matter if no shared config file was found
+    return new Response('', { status: 204 });
+  }
+}
+
+/**
+ * Adds the [[`SharedConfig`]] props to the page props
+ * @param _context
+ * @param _params
+ */
+export const withSharedConfig: MosaicMiddleware<SharedConfigSlice> = async (
+  context: GetServerSidePropsContext
+) => {
+  const { resolvedUrl, res } = context;
+  const isStatic = res.getHeader('X-Mosaic-Mode') === 'static';
+  const matches = resolvedUrl.match(/(.*)[!/]/);
+  const urlPath = matches?.length ? matches[1] : '';
+  const mosaicUrl = isStatic ? '' : res.getHeader('X-Mosaic-Content-Url');
+  const sharedConfigUrl = `${mosaicUrl}${urlPath}/shared-config.json`;
+  let response;
+  try {
+    response = isStatic
+      ? await readSharedConfig(sharedConfigUrl)
+      : await fetchSharedConfig(sharedConfigUrl);
+
+    if (response.ok && response.status !== 204) {
+      const { config } = (await response.json()) as { config: SharedConfig };
+
+      return { props: { sharedConfig: config } };
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+      throw new MiddlewareError(500, sharedConfigUrl, [error.message], { show500: true });
+    } else {
+      console.error('unexpected error');
+      throw new MiddlewareError(500, sharedConfigUrl, ['unexpected error'], { show500: true });
+    }
+  }
+  const show500 = response.status !== 404 && response.status !== 204;
+  const show404 = response.status === 404;
+  let errorMessage = `Could not find any shared config defined for ${sharedConfigUrl}`;
+  if (show500) {
+    errorMessage = `An un-expected error occurred reading ${sharedConfigUrl}`;
+  }
+  throw new MiddlewareError(response.status, sharedConfigUrl, [errorMessage], {
+    show404,
+    show500
+  });
+};

package/src/withStaticContent.ts

@@ -0,0 +1,45 @@
+import path from 'path';
+import fs from 'fs';
+
+import { compileMDX } from './compileMdx.js';
+import { MosaicMiddleware } from './createMiddlewareRunner.js';
+import MiddlewareError from './MiddlewareError.js';
+import { ContentProps } from './withContent.js';
+
+/**
+ * Adds the [[`ContentProps`]] object to the page props
+ * @param context
+ */
+export const withStaticContent: MosaicMiddleware<ContentProps> = async context => {
+  const { resolvedUrl, res } = context;
+  const isStatic = res.getHeader('X-Mosaic-Mode') === 'static';
+
+  if (!isStatic) {
+    return {};
+  }
+  const mosaicSnapshotDir = process.env.MOSAIC_SNAPSHOT_DIR || '';
+  // Find the absolute path for  the file/dir requested
+  const filePath = path.posix.join(process.cwd(), mosaicSnapshotDir, resolvedUrl);
+
+  try {
+    const realPath = await fs.promises.realpath(filePath);
+    const extname = path.extname(realPath);
+    if (extname === '.mdx') {
+      const data = await fs.promises.readFile(filePath, 'utf-8');
+      const text = data.toString();
+      const mdxSource = await compileMDX(text);
+      return { props: { type: 'mdx', source: mdxSource, raw: text } };
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error.message);
+      throw new MiddlewareError(500, resolvedUrl, [error.message], { show500: true });
+    } else {
+      console.error('unexpected error');
+      throw new MiddlewareError(500, resolvedUrl, ['unexpected error'], { show500: true });
+    }
+  }
+  throw new MiddlewareError(404, resolvedUrl, [`Could not find any content for ${resolvedUrl}`], {
+    show404: true
+  });
+};

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.bundle.json",
+  "compilerOptions": {
+    "emitDeclarationOnly": false,
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "include": ["src"],
+  "exclude": ["src/**/__tests__/**/*", "src/__tests__/**/*"]
+}