@openstax/ts-utils 1.33.1 → 1.34.0

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

@@ -1,125 +0,0 @@
-/* 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],
-            ['starts-with', '$Content-Type', ''],
-        ];
-        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

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

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

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

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

@@ -1,23 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

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

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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,5 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,70 +0,0 @@
-import { LrsGateway, UXapiStatement } from '.';
-export type ActivityState = {
-    attempts: number;
-    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>;