@openstax/ts-utils 1.33.1 → 1.34.0

package/packages/utils/src/services/launchParams/verifier.ts

@@ -0,0 +1,120 @@
+import jwt, { TokenExpiredError } from 'jsonwebtoken';
+import { JwksClient } from 'jwks-rsa';
+import type { JWK } from 'node-jose';
+import { memoize } from '../..';
+import { ConfigProviderForConfig, resolveConfigValue } from '../../config';
+import { InvalidRequestError, SessionExpiredError } from '../../errors';
+import { ifDefined } from '../../guards';
+import { once } from '../../misc/helpers';
+
+type Config = {
+  trustedDomain: string;
+  bypassSignatureVerification: string;
+};
+interface Initializer<C> {
+  configSpace?: C;
+  fetcher?: (uri: string) => Promise<{ keys: JWK.RawKey[] }>; // Leave unset outside of tests
+}
+
+/**
+ * Creates a class that can verify launch params
+ */
+export const createLaunchVerifier = <C extends string = 'launch'>({configSpace, fetcher}: Initializer<C>) => (configProvider: {[_key in C]: ConfigProviderForConfig<Config>}) => {
+  const config = configProvider[ifDefined(configSpace, 'launch' as C)];
+  const getTrustedDomain = once(() => resolveConfigValue(config.trustedDomain));
+  const getBypassSignatureVerification = once(async () =>
+    (await resolveConfigValue(config.bypassSignatureVerification)) === 'true'
+  );
+
+  const getJwksClient = memoize((jwksUri: string) => new JwksClient({ fetcher, jwksUri }));
+
+  const getJwksKey = memoize(async(jwksUri: string, kid?: string) => {
+    const client = getJwksClient(jwksUri);
+    const key = await client.getSigningKey(kid);
+    return key.getPublicKey();
+  });
+
+  const getKey = async(header: jwt.JwtHeader & { iss?: string }, callback: jwt.SigningKeyCallback) => {
+    // The JWT spec allows iss in the header as a copy of the iss claim, but we require it
+    if (!header.iss) {
+      return callback(new Error('JWT header missing iss claim'));
+    }
+
+    const { iss, kid } = header;
+    try {
+      const jwksUrl = new URL('/.well-known/jwks.json', iss);
+      const launchDomain = jwksUrl.hostname;
+      const trustedDomain = await getTrustedDomain();
+      if (launchDomain !== trustedDomain && !launchDomain.endsWith(`.${trustedDomain}`)) {
+        return callback(new Error(`Untrusted launch domain: "${launchDomain}"`));
+      }
+
+      callback(null, await getJwksKey(jwksUrl.toString(), kid));
+    } catch(error: any) {
+      callback(error);
+    }
+  };
+
+  return (_services: {}, getDefaultToken?: () => string) => {
+
+    const verify = async<T = undefined>(...args:
+      T extends undefined ? ([] | [string]) : ([(input: any) => T] | [string, (input: any) => T])
+    ) => {
+      const [inputToken, validator] = args.length === 1
+        ? typeof args[0] === 'string'
+          ? [args[0], undefined]
+          : [undefined, args[0]]
+        : args;
+
+      const bypassSignatureVerification = await getBypassSignatureVerification();
+
+      return new Promise<T extends undefined ? jwt.JwtPayload : T>(
+        (resolve, reject) => {
+          const token = inputToken ?? getDefaultToken?.();
+
+          if (!token) {
+            return reject(
+              new InvalidRequestError('Missing token for launch verification')
+            );
+          }
+
+          const resolvePayload = (err: jwt.VerifyErrors | null, payload: jwt.JwtPayload | string | undefined | null) => {
+            if (err && err instanceof TokenExpiredError) {
+              reject(new SessionExpiredError());
+            } else if (err) {
+              reject(err);
+            } else if (typeof payload !== 'object' || payload === null) {
+              reject(new Error('received JWT token with unexpected non-JSON payload'));
+            } else if (!payload.sub) {
+              reject(new Error('JWT payload missing sub claim'));
+            } else {
+              // we are migrating away from json encoding all the parameters into the `sub` claim
+              // and into using separate claims for each parameter. in transition, we check if the sub
+              // is json and return it if it is. this is still a breaking change when using this
+              // utility because applications no longer need to independently json parse the result
+              // starting now.
+              const parsed = payload;
+              try {
+                const jsonSubContents = JSON.parse(payload.sub);
+                Object.assign(parsed, jsonSubContents);
+              } catch (e) { } // eslint-disable-line no-empty
+
+              // conditional return types are annoying
+              resolve((validator ? validator(parsed) : parsed) as any);
+            }
+          };
+
+          if (bypassSignatureVerification) {
+            return resolvePayload(null, jwt.decode(token));
+          } else {
+            return jwt.verify(token, getKey, {}, resolvePayload);
+          }
+        }
+      );
+    };
+
+    return { verify };
+  };
+};
+
+export type LaunchVerifier = ReturnType<ReturnType<ReturnType<typeof createLaunchVerifier>>>;

package/packages/utils/src/services/logger/console.spec.ts

@@ -0,0 +1,29 @@
+import { createConsoleLogger } from './console';
+import { Level, Logger } from '.';
+
+describe('createConsoleLogger', () => {
+  let logFn: jest.SpyInstance;
+  let logger: Logger;
+
+  beforeEach(() => {
+    logger = createConsoleLogger();
+    logFn = jest.spyOn(console, 'info').mockImplementation(() => null);
+  });
+
+  afterEach(() => {
+    logFn.mockReset();
+  });
+
+  it('logs', () => {
+    logger.setContext({extra: 'context'});
+    logger.logEvent(Level.Info, {message: 'hello'});
+
+    expect(logFn).toHaveBeenCalledWith(JSON.stringify({
+      eventType: 'INFO',
+      message: 'hello',
+      context: {
+        extra: 'context',
+      },
+    }));
+  });
+});

package/{dist/esm/services/logger/console.js → packages/utils/src/services/logger/console.ts}

@@ -1,8 +1,11 @@
 import { createCoreLogger } from '.';
+
 /**
  * Creates a logger that logs to the console.
  */
-export const createConsoleLogger = () => createCoreLogger((level, event) => console[level](JSON.stringify({
+export const createConsoleLogger = () => createCoreLogger((level, event) =>
+  console[level](JSON.stringify({
     eventType: level.toUpperCase(),
     ...event,
-})));
+  }))
+);

package/packages/utils/src/services/logger/index.spec.ts

@@ -0,0 +1,65 @@
+import { createCoreLogger, Level, LogEvent, Logger } from '.';
+
+describe('createCoreLogger', () => {
+  let logFn: jest.SpyInstance;
+  let logger: Logger;
+
+  beforeEach(() => {
+    logFn = jest.fn();
+    logger = createCoreLogger(logFn as any as LogEvent);
+  });
+
+  it('appends context to log events', () => {
+    logger.setContext({extra: 'context'});
+    logger.logEvent(Level.Info, {message: 'hello'});
+
+    expect(logFn).toHaveBeenCalledWith(Level.Info, {
+      context: {
+        extra: 'context',
+      },
+      message: 'hello',
+    });
+  });
+
+  it('appends context to logs', () => {
+    logger.setContext({extra: 'context'});
+    logger.log('hello');
+
+    expect(logFn).toHaveBeenCalledWith(Level.Info, {
+      context: {
+        extra: 'context',
+      },
+      message: 'hello',
+    });
+  });
+
+  it('includes context from parent and sub-context', () => {
+    logger.setContext({extra: 'context'});
+    const subContext = logger.createSubContext();
+    subContext.setContext({extra2: 'extra context'});
+    subContext.log('hello');
+
+    expect(logFn).toHaveBeenCalledWith(Level.Info, {
+      context: {
+        extra: 'context',
+        extra2: 'extra context',
+      },
+      message: 'hello',
+    });
+  });
+
+  it('includes context from parent after sub-context is created', () => {
+    const subContext = logger.createSubContext();
+    subContext.setContext({extra2: 'extra context'});
+    logger.setContext({extra: 'context'});
+    subContext.log('hello');
+
+    expect(logFn).toHaveBeenCalledWith(Level.Info, {
+      context: {
+        extra: 'context',
+        extra2: 'extra context',
+      },
+      message: 'hello',
+    });
+  });
+});

package/{dist/esm/services/logger/index.d.ts → packages/utils/src/services/logger/index.ts}

@@ -1,12 +1,14 @@
 import { JsonCompatibleStruct } from '../../routing';
+
 /**
  * The log level
  */
-export declare enum Level {
-    Info = "info",
-    Warn = "warn",
-    Error = "error"
+export enum Level {
+  Info='info',
+  Warn='warn',
+  Error='error',
 }
+
 /**
  * A function that logs an event at a certain level.
  *
@@ -14,6 +16,7 @@ export declare enum Level {
  * @param event - event to log
  */
 export type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
+
 /**
  * A logger that can be used to log events.
  *
@@ -23,11 +26,12 @@ export type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
  * @property createSubContext - creates a new logger that inherits the context of this logger
  */
 export interface Logger {
-    setContext: (obj: JsonCompatibleStruct) => void;
-    logEvent: LogEvent;
-    log: (message: string, level?: Level) => void;
-    createSubContext: () => Logger;
+  setContext: (obj: JsonCompatibleStruct) => void;
+  logEvent: LogEvent;
+  log: (message: string, level?: Level) => void;
+  createSubContext: () => Logger;
 }
+
 /**
  * Creates a logger that logs events using the given driver and context provider.
  *
@@ -36,4 +40,14 @@ export interface Logger {
  *   (the context is returned when messages are logged with the logger)
  * @returns a Logger
  */
-export declare const createCoreLogger: (driver: LogEvent, getParentContext?: () => JsonCompatibleStruct) => Logger;
+export const createCoreLogger = (driver: LogEvent, getParentContext?: () => JsonCompatibleStruct): Logger => {
+  const context = {};
+  const getContext = () => ({...getParentContext?.(), ...context});
+
+  return {
+    logEvent: (level, event) => driver(level, {...event, context: getContext()}),
+    log: (message, level = Level.Info) => driver(level, {message, context: getContext()}),
+    setContext: (obj) => { Object.assign(context, obj); },
+    createSubContext: () => createCoreLogger(driver, getContext),
+  };
+};

package/packages/utils/src/services/lrsGateway/README.md

@@ -0,0 +1,5 @@
+# lrsGateway
+
+typing/formatting for interacting with Learning Record Stores
+
+https://github.com/adlnet/xAPI-Spec/blob/master/xAPI-About.md#def-learning-record-store

package/packages/utils/src/services/lrsGateway/addStatementDefaultFields.ts

@@ -0,0 +1,22 @@
+import formatISO from 'date-fns/formatISO';
+import { v4 as uuid } from 'uuid';
+import { User } from '../authProvider';
+import { EagerXapiStatement, UXapiStatement, XapiStatement } from '.';
+
+export const addStatementDefaultFields = (
+  statement: Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+    id?: string;
+  } | UXapiStatement,
+  user: User
+): EagerXapiStatement => ({
+  id: uuid(),
+  actor: {
+    account: {
+      homePage: 'https://openstax.org',
+      name: user.uuid,
+    },
+    objectType: 'Agent',
+  },
+  timestamp: formatISO(new Date()),
+  ...statement,
+});