@openstax/ts-utils 1.34.0 → 1.35.0

package/dist/esm/services/fileServer/s3FileServer.js

@@ -0,0 +1,124 @@
+/* cspell:ignore presigner */
+import path from 'path';
+import { CopyObjectCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { createPresignedPost } from '@aws-sdk/s3-presigned-post';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { v4 as uuid } from 'uuid';
+import { once } from '../..';
+import { assertDefined } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+export const s3FileServer = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
+    const bucketName = once(() => resolveConfigValue(config.bucketName));
+    const bucketRegion = once(() => resolveConfigValue(config.bucketRegion));
+    const publicViewerDomain = once(() => 'publicViewerDomain' in config && config.publicViewerDomain
+        ? resolveConfigValue(config.publicViewerDomain)
+        : undefined);
+    const s3Service = once(async () => {
+        var _a, _b;
+        const args = { apiVersion: '2012-08-10', region: await bucketRegion() };
+        return (_b = (_a = initializer.getS3Client) === null || _a === void 0 ? void 0 : _a.call(initializer, args)) !== null && _b !== void 0 ? _b : new S3Client(args);
+    });
+    /*
+     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/ShareObjectPreSignedURL.html
+     */
+    const getSignedViewerUrl = async (source) => {
+        const bucket = (await bucketName());
+        const command = new GetObjectCommand({ Bucket: bucket, Key: source.path });
+        return getSignedUrl(await s3Service(), command, {
+            expiresIn: 3600, // 1 hour
+        });
+    };
+    const getPublicViewerUrl = async (source) => {
+        const host = assertDefined(await publicViewerDomain(), new Error(`Tried to get public viewer URL for ${source.path} but no publicViewerDomain configured`));
+        return `https://${host}/${source.path}`;
+    };
+    const getFileContent = async (source) => {
+        const bucket = await bucketName();
+        const command = new GetObjectCommand({ Bucket: bucket, Key: source.path });
+        const response = await (await s3Service()).send(command);
+        return Buffer.from(await assertDefined(response.Body, new Error('Invalid Response from s3')).transformToByteArray());
+    };
+    const putFileContent = async (source, content) => {
+        const bucket = await bucketName();
+        const command = new PutObjectCommand({
+            Bucket: bucket,
+            Key: source.path,
+            Body: content,
+            ContentType: source.mimeType,
+        });
+        await (await s3Service()).send(command);
+        return source;
+    };
+    /*
+     * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_s3_presigned_post.html
+     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/HTTPPOSTExamples.html
+     * https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-post-example.html
+     */
+    const getSignedFileUploadConfig = async () => {
+        const prefix = 'uploads/' + uuid();
+        const bucket = (await bucketName());
+        const Conditions = [
+            { acl: 'private' },
+            { bucket },
+            ['starts-with', '$key', prefix]
+        ];
+        const defaultFields = {
+            acl: 'private',
+        };
+        const { url, fields } = await createPresignedPost(await s3Service(), {
+            Bucket: bucket,
+            Key: prefix + '/${filename}',
+            Conditions,
+            Fields: defaultFields,
+            Expires: 3600, // 1 hour
+        });
+        return {
+            url, payload: fields
+        };
+    };
+    const copyFileTo = async (source, destinationPath) => {
+        const bucket = (await bucketName());
+        const destinationPathWithoutLeadingSlash = destinationPath.replace(/^\//, '');
+        const command = new CopyObjectCommand({
+            Bucket: bucket,
+            Key: destinationPathWithoutLeadingSlash,
+            CopySource: path.join(bucket, source.path),
+        });
+        await (await s3Service()).send(command);
+        return {
+            ...source,
+            path: destinationPathWithoutLeadingSlash
+        };
+    };
+    const copyFileToDirectory = async (source, destination) => {
+        const destinationPath = path.join(destination, source.label);
+        return copyFileTo(source, destinationPath);
+    };
+    const isTemporaryUpload = (source) => {
+        return source.path.indexOf('uploads/') === 0;
+    };
+    const getFileChecksum = async (source) => {
+        const bucket = (await bucketName());
+        const command = new HeadObjectCommand({ Bucket: bucket, Key: source.path });
+        const response = await (await s3Service()).send(command);
+        return assertDefined(response.ETag);
+    };
+    const filesEqual = async (sourceA, sourceB) => {
+        const [aSum, bSum] = await Promise.all([getFileChecksum(sourceA), getFileChecksum(sourceB)]);
+        return aSum === bSum;
+    };
+    return {
+        getFileContent,
+        putFileContent,
+        getSignedViewerUrl,
+        getPublicViewerUrl,
+        getSignedFileUploadConfig,
+        copyFileTo,
+        copyFileToDirectory,
+        isTemporaryUpload,
+        getFileChecksum,
+        filesEqual,
+    };
+};

package/dist/esm/services/launchParams/index.d.ts

@@ -0,0 +1,2 @@
+export { createLaunchSigner } from './signer';
+export { createLaunchVerifier } from './verifier';

package/dist/esm/services/launchParams/index.js

@@ -0,0 +1,2 @@
+export { createLaunchSigner } from './signer';
+export { createLaunchVerifier } from './verifier';

package/dist/esm/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/esm/services/launchParams/signer.js

@@ -0,0 +1,51 @@
+import jwt from 'jsonwebtoken';
+import ms from 'ms';
+import { JWK } from 'node-jose';
+import { once } from '../..';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../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
+ */
+export const createLaunchSigner = ({ configSpace }) => (configProvider) => {
+    const config = configProvider[ifDefined(configSpace, 'launch')];
+    const getAlg = once(async () => assertAlg(await resolveConfigValue(config.alg)));
+    const getExpiresIn = once(() => resolveConfigValue(config.expiresIn));
+    const getIss = once(() => resolveConfigValue(config.iss));
+    const getPrivateKey = once(() => resolveConfigValue(config.privateKey));
+    const getKeyStore = once(async () => {
+        const keystore = 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(ms(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 jwt.sign(data, await getPrivateKey(), { algorithm: alg, expiresIn, header, issuer: iss, subject });
+    };
+    return { jwks, sign };
+};

package/dist/esm/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/esm/services/launchParams/verifier.js

@@ -0,0 +1,92 @@
+import jwt, { TokenExpiredError } from 'jsonwebtoken';
+import { JwksClient } from 'jwks-rsa';
+import { memoize } from '../..';
+import { resolveConfigValue } from '../../config';
+import { InvalidRequestError, SessionExpiredError } from '../../errors';
+import { ifDefined } from '../../guards';
+import { once } from '../../misc/helpers';
+/**
+ * Creates a class that can verify launch params
+ */
+export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvider) => {
+    const config = configProvider[ifDefined(configSpace, 'launch')];
+    const getTrustedDomain = once(() => resolveConfigValue(config.trustedDomain));
+    const getBypassSignatureVerification = once(async () => (await resolveConfigValue(config.bypassSignatureVerification)) === 'true');
+    const getJwksClient = memoize((jwksUri) => new JwksClient({ fetcher, jwksUri }));
+    const getJwksKey = 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 InvalidRequestError('Missing token for launch verification'));
+                }
+                const resolvePayload = (err, payload) => {
+                    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));
+                    }
+                };
+                if (bypassSignatureVerification) {
+                    return resolvePayload(null, jwt.decode(token));
+                }
+                else {
+                    return jwt.verify(token, getKey, {}, resolvePayload);
+                }
+            });
+        };
+        return { verify };
+    };
+};

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

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

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

@@ -1,11 +1,8 @@
 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/dist/esm/services/logger/index.d.ts

@@ -0,0 +1,39 @@
+import { JsonCompatibleStruct } from '../../routing';
+/**
+ * The log level
+ */
+export declare enum Level {
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+/**
+ * A function that logs an event at a certain level.
+ *
+ * @param level - log level
+ * @param event - event to log
+ */
+export type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
+/**
+ * A logger that can be used to log events.
+ *
+ * @property setContext - sets a context object to be included in all future logged events
+ * @property logEvent - logs an arbitrary event at a certain level, without context
+ * @property log - logs a message and the context at a certain level
+ * @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;
+}
+/**
+ * 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
+ */
+export declare const createCoreLogger: (driver: LogEvent, getParentContext?: () => JsonCompatibleStruct) => Logger;

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

@@ -0,0 +1,27 @@
+/**
+ * The log level
+ */
+export var Level;
+(function (Level) {
+    Level["Info"] = "info";
+    Level["Warn"] = "warn";
+    Level["Error"] = "error";
+})(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
+ */
+export 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: () => createCoreLogger(driver, getContext),
+    };
+};

package/dist/esm/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/esm/services/lrsGateway/addStatementDefaultFields.js

@@ -0,0 +1,14 @@
+import formatISO from 'date-fns/formatISO';
+import { v4 as uuid } from 'uuid';
+export const addStatementDefaultFields = (statement, user) => ({
+    id: uuid(),
+    actor: {
+        account: {
+            homePage: 'https://openstax.org',
+            name: user.uuid,
+        },
+        objectType: 'Agent',
+    },
+    timestamp: formatISO(new Date()),
+    ...statement,
+});

package/dist/esm/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>;