@openstax/ts-utils 1.34.0 → 1.35.0

package/dist/cjs/services/launchParams/signer.d.ts

@@ -0,0 +1,23 @@
+import { JWK } from 'node-jose';
+import { ConfigProviderForConfig } from '../../config';
+import type { JsonCompatibleStruct } from '../../routing';
+type Config = {
+    alg: string;
+    expiresIn: string;
+    iss: string;
+    privateKey: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+}
+/**
+ * Creates a class that can sign launch params
+ */
+export declare const createLaunchSigner: <C extends string = "launch">({ configSpace }: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => {
+    jwks: () => Promise<{
+        keys: JWK.RawKey[];
+    }>;
+    sign: (data: JsonCompatibleStruct, subject: string, maxExp?: number | null) => Promise<string>;
+};
+export type LaunchSigner = ReturnType<ReturnType<typeof createLaunchSigner>>;
+export {};

package/dist/cjs/services/launchParams/signer.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchSigner = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const ms_1 = __importDefault(require("ms"));
+const node_jose_1 = require("node-jose");
+const __1 = require("../..");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const SUPPORTED_ALGORITHMS = [
+    'RS256', 'RS384', 'RS512', 'ES256', 'ES384', 'ES512', 'HS256', 'HS384', 'HS512', 'PS256', 'PS384', 'PS512'
+];
+const assertAlg = (alg) => {
+    if ((SUPPORTED_ALGORITHMS).includes(alg)) {
+        return alg;
+    }
+    throw new Error(`"${alg}" is not a valid algorithm`);
+};
+/**
+ * Creates a class that can sign launch params
+ */
+const createLaunchSigner = ({ configSpace }) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(configSpace, 'launch')];
+    const getAlg = (0, __1.once)(async () => assertAlg(await (0, config_1.resolveConfigValue)(config.alg)));
+    const getExpiresIn = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.expiresIn));
+    const getIss = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.iss));
+    const getPrivateKey = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.privateKey));
+    const getKeyStore = (0, __1.once)(async () => {
+        const keystore = node_jose_1.JWK.createKeyStore();
+        await keystore.add(await getPrivateKey(), 'pem');
+        return keystore;
+    });
+    const jwks = async () => (await getKeyStore()).toJSON(false);
+    const getExpiresInWithMax = async (maxExp) => {
+        const expiresIn = await getExpiresIn();
+        // The ms library used by jsonwebtoken can handle a value in seconds as well as a string like '1d'
+        if (!maxExp) {
+            return expiresIn;
+        }
+        // Convert both values to seconds for comparison
+        const expiresInSeconds = Math.floor((0, ms_1.default)(expiresIn) / 1000);
+        const maxExpSeconds = maxExp - Math.floor(Date.now() / 1000);
+        return Math.min(expiresInSeconds, maxExpSeconds);
+    };
+    const sign = async (data, subject, maxExp) => {
+        const alg = await getAlg();
+        // expiresIn can be a number of seconds or a string like '1h' or '1d'
+        const expiresIn = await getExpiresInWithMax(maxExp);
+        const iss = await getIss();
+        const header = { alg, iss };
+        return jsonwebtoken_1.default.sign(data, await getPrivateKey(), { algorithm: alg, expiresIn, header, issuer: iss, subject });
+    };
+    return { jwks, sign };
+};
+exports.createLaunchSigner = createLaunchSigner;

package/dist/cjs/services/launchParams/verifier.d.ts

@@ -0,0 +1,21 @@
+import jwt from 'jsonwebtoken';
+import type { JWK } from 'node-jose';
+import { ConfigProviderForConfig } from '../../config';
+type Config = {
+    trustedDomain: string;
+    bypassSignatureVerification: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetcher?: (uri: string) => Promise<{
+        keys: JWK.RawKey[];
+    }>;
+}
+/**
+ * Creates a class that can verify launch params
+ */
+export declare const createLaunchVerifier: <C extends string = "launch">({ configSpace, fetcher }: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => (_services: {}, getDefaultToken?: () => string) => {
+    verify: <T = undefined>(...args: T extends undefined ? ([] | [string]) : ([(input: any) => T] | [string, (input: any) => T])) => Promise<T extends undefined ? jwt.JwtPayload : T>;
+};
+export type LaunchVerifier = ReturnType<ReturnType<ReturnType<typeof createLaunchVerifier>>>;
+export {};

package/dist/cjs/services/launchParams/verifier.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchVerifier = void 0;
+const jsonwebtoken_1 = __importStar(require("jsonwebtoken"));
+const jwks_rsa_1 = require("jwks-rsa");
+const __1 = require("../..");
+const config_1 = require("../../config");
+const errors_1 = require("../../errors");
+const guards_1 = require("../../guards");
+const helpers_1 = require("../../misc/helpers");
+/**
+ * Creates a class that can verify launch params
+ */
+const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(configSpace, 'launch')];
+    const getTrustedDomain = (0, helpers_1.once)(() => (0, config_1.resolveConfigValue)(config.trustedDomain));
+    const getBypassSignatureVerification = (0, helpers_1.once)(async () => (await (0, config_1.resolveConfigValue)(config.bypassSignatureVerification)) === 'true');
+    const getJwksClient = (0, __1.memoize)((jwksUri) => new jwks_rsa_1.JwksClient({ fetcher, jwksUri }));
+    const getJwksKey = (0, __1.memoize)(async (jwksUri, kid) => {
+        const client = getJwksClient(jwksUri);
+        const key = await client.getSigningKey(kid);
+        return key.getPublicKey();
+    });
+    const getKey = async (header, callback) => {
+        // 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) {
+            callback(error);
+        }
+    };
+    return (_services, getDefaultToken) => {
+        const verify = async (...args) => {
+            const [inputToken, validator] = args.length === 1
+                ? typeof args[0] === 'string'
+                    ? [args[0], undefined]
+                    : [undefined, args[0]]
+                : args;
+            const bypassSignatureVerification = await getBypassSignatureVerification();
+            return new Promise((resolve, reject) => {
+                const token = inputToken !== null && inputToken !== void 0 ? inputToken : getDefaultToken === null || getDefaultToken === void 0 ? void 0 : getDefaultToken();
+                if (!token) {
+                    return reject(new errors_1.InvalidRequestError('Missing token for launch verification'));
+                }
+                const resolvePayload = (err, payload) => {
+                    if (err && err instanceof jsonwebtoken_1.TokenExpiredError) {
+                        reject(new errors_1.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));
+                    }
+                };
+                if (bypassSignatureVerification) {
+                    return resolvePayload(null, jsonwebtoken_1.default.decode(token));
+                }
+                else {
+                    return jsonwebtoken_1.default.verify(token, getKey, {}, resolvePayload);
+                }
+            });
+        };
+        return { verify };
+    };
+};
+exports.createLaunchVerifier = createLaunchVerifier;

package/dist/cjs/services/logger/console.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Creates a logger that logs to the console.
+ */
+export declare const createConsoleLogger: () => import(".").Logger;

package/dist/cjs/services/logger/console.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConsoleLogger = void 0;
+const _1 = require(".");
+/**
+ * Creates a logger that logs to the console.
+ */
+const createConsoleLogger = () => (0, _1.createCoreLogger)((level, event) => console[level](JSON.stringify({
+    eventType: level.toUpperCase(),
+    ...event,
+})));
+exports.createConsoleLogger = createConsoleLogger;

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

@@ -1,14 +1,12 @@
 import { JsonCompatibleStruct } from '../../routing';
-
 /**
  * The log level
  */
-export enum Level {
-  Info='info',
-  Warn='warn',
-  Error='error',
+export declare enum Level {
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
 }
-
 /**
  * A function that logs an event at a certain level.
  *
@@ -16,7 +14,6 @@ export enum Level {
  * @param event - event to log
  */
 export type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
-
 /**
  * A logger that can be used to log events.
  *
@@ -26,12 +23,11 @@ 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.
  *
@@ -40,14 +36,4 @@ export interface Logger {
  *   (the context is returned when messages are logged with the logger)
  * @returns a 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),
-  };
-};
+export declare const createCoreLogger: (driver: LogEvent, getParentContext?: () => JsonCompatibleStruct) => Logger;

package/dist/cjs/services/logger/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCoreLogger = exports.Level = void 0;
+/**
+ * The log level
+ */
+var Level;
+(function (Level) {
+    Level["Info"] = "info";
+    Level["Warn"] = "warn";
+    Level["Error"] = "error";
+})(Level || (exports.Level = Level = {}));
+/**
+ * Creates a logger that logs events using the given driver and context provider.
+ *
+ * @param driver the driver that logs events
+ * @param getParentContext a provider that returns the context to use for this logger
+ *   (the context is returned when messages are logged with the logger)
+ * @returns a Logger
+ */
+const createCoreLogger = (driver, getParentContext) => {
+    const context = {};
+    const getContext = () => ({ ...getParentContext === null || getParentContext === void 0 ? void 0 : 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: () => (0, exports.createCoreLogger)(driver, getContext),
+    };
+};
+exports.createCoreLogger = createCoreLogger;

package/dist/cjs/services/lrsGateway/addStatementDefaultFields.d.ts

@@ -0,0 +1,5 @@
+import { User } from '../authProvider';
+import { EagerXapiStatement, UXapiStatement, XapiStatement } from '.';
+export declare const addStatementDefaultFields: (statement: (Pick<XapiStatement, "object" | "verb" | "context" | "result"> & {
+    id?: string;
+}) | UXapiStatement, user: User) => EagerXapiStatement;

package/dist/cjs/services/lrsGateway/addStatementDefaultFields.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addStatementDefaultFields = void 0;
+const formatISO_1 = __importDefault(require("date-fns/formatISO"));
+const uuid_1 = require("uuid");
+const addStatementDefaultFields = (statement, user) => ({
+    id: (0, uuid_1.v4)(),
+    actor: {
+        account: {
+            homePage: 'https://openstax.org',
+            name: user.uuid,
+        },
+        objectType: 'Agent',
+    },
+    timestamp: (0, formatISO_1.default)(new Date()),
+    ...statement,
+});
+exports.addStatementDefaultFields = addStatementDefaultFields;

package/dist/cjs/services/lrsGateway/attempt-utils.d.ts

@@ -0,0 +1,72 @@
+import { LrsGateway, UXapiStatement } from '.';
+export type ActivityState = {
+    attempts: number;
+    bestCompletedAttempt?: UXapiStatement;
+    bestCompletedAttemptCompleted?: UXapiStatement;
+    completedAttempts: number;
+    currentAttempt?: UXapiStatement;
+    currentAttemptCompleted?: UXapiStatement;
+    currentAttemptStatements: UXapiStatement[];
+    mostRecentAttemptWithCompleted?: UXapiStatement;
+    mostRecentAttemptWithCompletedCompleted?: UXapiStatement;
+};
+export declare const matchAttempt: (statement: UXapiStatement) => boolean;
+export declare const matchAttemptCompleted: (attempt: UXapiStatement) => (statement: UXapiStatement) => boolean;
+export declare const resolveAttempts: (statements: UXapiStatement[], options?: {
+    activityIRI?: string;
+    parentActivityAttempt?: string;
+}) => UXapiStatement[];
+export declare const resolveCompletedForAttempt: (statements: UXapiStatement[], attempt: UXapiStatement, activityIRI?: string) => UXapiStatement | undefined;
+export declare const oldestStatement: (statements: UXapiStatement[]) => UXapiStatement | undefined;
+export declare const mostRecentStatement: (statements: UXapiStatement[]) => UXapiStatement | undefined;
+export declare const resolveAttemptInfo: (statements: UXapiStatement[], options?: {
+    activityIRI?: string;
+    currentAttempt?: string;
+    parentActivityAttempt?: string;
+    currentPreference?: "latest" | "oldest";
+}) => ActivityState;
+export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGateway, activityIRI: string, options?: {
+    anyUser?: boolean;
+    attempt?: string;
+    ensureSync?: boolean;
+    user?: string;
+}) => Promise<import(".").XapiStatement[]>;
+export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
+    currentAttempt?: string;
+    parentActivityAttempt?: string;
+    ensureSync?: boolean;
+}) => Promise<ActivityState>;
+export declare const createStatement: (verb: UXapiStatement["verb"], activity: {
+    iri: string;
+    type: string;
+    name: string;
+    extensions?: {
+        [key: string]: string;
+    };
+}, attempt: string, parentActivityIRI?: string) => Pick<UXapiStatement, "object" | "verb" | "context">;
+export declare const createAttemptStatement: (activity: {
+    iri: string;
+    type: string;
+    name: string;
+    extensions?: {
+        [key: string]: string;
+    };
+}, parentActivity?: {
+    iri?: string;
+    attempt?: string;
+}) => Pick<UXapiStatement, "object" | "verb" | "context">;
+export declare const putAttemptStatement: (gateway: LrsGateway, activity: {
+    iri: string;
+    type: string;
+    name: string;
+    extensions?: {
+        [key: string]: string;
+    };
+}, parentActivity?: {
+    iri?: string;
+    attempt?: string;
+}) => Promise<import(".").EagerXapiStatement>;
+export declare const createAttemptActivityStatement: (attemptStatement: UXapiStatement, verb: UXapiStatement["verb"], result?: UXapiStatement["result"]) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
+export declare const putAttemptActivityStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, verb: UXapiStatement["verb"], result?: UXapiStatement["result"]) => Promise<import(".").EagerXapiStatement>;
+export declare const createCompletedStatement: (attemptStatement: UXapiStatement, result?: UXapiStatement["result"]) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
+export declare const putCompletedStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement["result"]) => Promise<import(".").EagerXapiStatement>;