@openstax/ts-utils 1.1.26 → 1.1.28

package/dist/esm/services/authProvider/decryption.js

@@ -0,0 +1,61 @@
+import { compactDecrypt, compactVerify, importSPKI } from 'jose';
+import { once } from '../..';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+import { getAuthTokenOrCookie } from '.';
+export const decryptionAuthProvider = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'decryption')];
+    const cookieName = once(() => resolveConfigValue(config.cookieName));
+    const encryptionPrivateKey = once(() => resolveConfigValue(config.encryptionPrivateKey));
+    const signaturePublicKey = once(() => resolveConfigValue(config.signaturePublicKey));
+    const decryptAndVerify = async (jwt) => {
+        try {
+            // Decrypt SSO cookie
+            const { plaintext } = await compactDecrypt(jwt, Buffer.from(await encryptionPrivateKey()), // Note: Buffer.from() is node-js only
+            { contentEncryptionAlgorithms: ['A256GCM'], keyManagementAlgorithms: ['dir'] });
+            // Verify SSO cookie signature
+            const { payload } = await compactVerify(plaintext, await importSPKI(await signaturePublicKey(), 'RS256'), { algorithms: ['RS256'] });
+            return payload;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return ({ request, profile }) => {
+        let user;
+        const getAuthorizedFetchConfig = profile.track('getAuthorizedFetchConfig', () => async () => {
+            const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
+            if (!token) {
+                return {};
+            }
+            return { headers };
+        });
+        const loadUser = profile.track('loadUser', () => async () => {
+            const [token] = getAuthTokenOrCookie(request, await cookieName());
+            if (!token) {
+                return undefined;
+            }
+            const payload = await decryptAndVerify(token);
+            if (!payload) {
+                return undefined;
+            }
+            // Note: Uint8Array.toString() returns text in node-js only
+            //       The browser version is new TextDecoder().decode(payload)
+            const jwt = JSON.parse(payload.toString());
+            // Allow clock skew up to 5 minutes
+            if (!jwt.sub || !jwt.sub.uuid || (jwt.exp && jwt.exp < Math.floor(Date.now() / 1000) - 300)) {
+                return undefined;
+            }
+            return jwt.sub;
+        });
+        return {
+            getAuthorizedFetchConfig,
+            getUser: async () => {
+                if (!user) {
+                    user = await loadUser();
+                }
+                return user;
+            }
+        };
+    };
+};

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

@@ -0,0 +1,42 @@
+import { FetchConfig } from '../../fetch';
+import { Track } from '../../profile';
+import { HttpHeaders } from '../../routing';
+export interface User {
+    id: number;
+    name: string;
+    first_name: string;
+    last_name: string;
+    full_name: string;
+    uuid: string;
+    faculty_status: string;
+    is_administrator: boolean;
+    is_not_gdpr_location: boolean;
+    contact_infos: Array<{
+        type: string;
+        value: string;
+        is_verified: boolean;
+        is_guessed_preferred: boolean;
+    }>;
+}
+export declare type AuthProvider = {
+    getUser: () => Promise<User | undefined>;
+    /**
+     * gets second argument for `fetch` that has authentication token or cookie
+     */
+    getAuthorizedFetchConfig: () => Promise<FetchConfig>;
+};
+export declare type CookieAuthProviderRequest = {
+    headers: HttpHeaders;
+    cookies?: string[];
+};
+export declare type CookieAuthProvider = (inputs: {
+    request: CookieAuthProviderRequest;
+    profile: Track;
+}) => AuthProvider;
+export declare type StubAuthProvider = (user: User | undefined) => AuthProvider;
+export declare const stubAuthProvider: (user?: User | undefined) => AuthProvider;
+export declare const getAuthTokenOrCookie: (request: CookieAuthProviderRequest, cookieName: string) => [string, {
+    Authorization: string;
+}] | [string, {
+    cookie: string;
+}];

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

@@ -0,0 +1,15 @@
+import cookie from 'cookie';
+import { tuple } from '../..';
+import { getHeader } from '../../routing';
+export const stubAuthProvider = (user) => ({
+    getUser: () => Promise.resolve(user),
+    getAuthorizedFetchConfig: () => Promise.resolve(user ? { headers: { Authorization: user.uuid } } : {})
+});
+export const getAuthTokenOrCookie = (request, cookieName) => {
+    var _a;
+    const authHeader = getHeader(request.headers, 'authorization');
+    const cookieValue = cookie.parse(((_a = request.cookies) === null || _a === void 0 ? void 0 : _a.join('; ')) || '')[cookieName];
+    return authHeader && authHeader.length >= 8 && authHeader.startsWith('Bearer ')
+        ? tuple(authHeader.slice(7), { Authorization: authHeader })
+        : tuple(cookieValue, { cookie: cookie.serialize(cookieName, cookieValue) });
+};

package/dist/esm/services/authProvider/subrequest.d.ts

@@ -0,0 +1,16 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { CookieAuthProvider } from '.';
+declare type Config = {
+    cookieName: string;
+    accountsUrl: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export declare const subrequestAuthProvider: <C extends string = "subrequest">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    cookieName: import("../../config").ConfigValueProvider<string>;
+    accountsUrl: import("../../config").ConfigValueProvider<string>;
+}; }) => CookieAuthProvider;
+export {};

package/dist/esm/services/authProvider/subrequest.js

@@ -0,0 +1,36 @@
+import { once } from '../..';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+import { getAuthTokenOrCookie } from '.';
+export const subrequestAuthProvider = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'subrequest')];
+    const cookieName = once(() => resolveConfigValue(config.cookieName));
+    const accountsUrl = once(() => resolveConfigValue(config.accountsUrl));
+    return ({ request, profile }) => {
+        let user;
+        const getAuthorizedFetchConfig = profile.track('getAuthorizedFetchConfig', () => async () => {
+            const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
+            if (!token) {
+                return {};
+            }
+            return { headers };
+        });
+        const loadUser = profile.track('loadUser', p => async () => {
+            const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
+            if (!token) {
+                return undefined;
+            }
+            return p.trackFetch(initializer.fetch)(await accountsUrl(), { headers })
+                .then(response => response.json());
+        });
+        return {
+            getAuthorizedFetchConfig,
+            getUser: async () => {
+                if (!user) {
+                    user = await loadUser();
+                }
+                return user;
+            }
+        };
+    };
+};

package/dist/esm/services/authProvider/utils/embeddedAuthProvider.d.ts

@@ -0,0 +1,20 @@
+import { User } from '..';
+import { Window } from '../browser';
+export declare type UserData = {
+    user?: User;
+    token: string | null;
+};
+declare type UserDataLoader = () => Promise<UserData>;
+export declare enum PostMessageTypes {
+    ReceiveUser = "receive-user",
+    RequestUser = "request-user"
+}
+export declare const embeddedAuthProvider: (getUserData: UserDataLoader, { queryKey, window }: {
+    queryKey?: string | undefined;
+    window: Window;
+}) => {
+    embeddedQueryValue: string;
+    getAuthorizedEmbedUrl: (urlString: string) => string;
+    unmount: () => void;
+};
+export {};

package/dist/esm/services/authProvider/utils/embeddedAuthProvider.js

@@ -0,0 +1,30 @@
+export var PostMessageTypes;
+(function (PostMessageTypes) {
+    PostMessageTypes["ReceiveUser"] = "receive-user";
+    PostMessageTypes["RequestUser"] = "request-user";
+})(PostMessageTypes || (PostMessageTypes = {}));
+export const embeddedAuthProvider = (getUserData, { queryKey = 'auth', window }) => {
+    const trustedEmbeds = new Set();
+    const embeddedQueryValue = 'embedded';
+    const messageHandler = event => {
+        if (event.data.type === PostMessageTypes.RequestUser && trustedEmbeds.has(event.origin)) {
+            getUserData().then(data => {
+                event.source.postMessage({ type: PostMessageTypes.ReceiveUser, userData: data }, event.origin);
+            });
+        }
+    };
+    window.addEventListener('message', messageHandler);
+    const getAuthorizedEmbedUrl = (urlString) => {
+        const url = new URL(urlString);
+        trustedEmbeds.add(url.origin);
+        url.searchParams.set(queryKey, embeddedQueryValue);
+        return url.href;
+    };
+    return {
+        embeddedQueryValue,
+        getAuthorizedEmbedUrl,
+        unmount: () => {
+            window.removeEventListener('message', messageHandler);
+        }
+    };
+};

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

@@ -0,0 +1,74 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { Track } from '../../profile';
+export declare type Config = {
+    defaultCorrectness?: string;
+    exercisesHost: string;
+    exercisesAuthToken: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export declare type Answer = {
+    id: number;
+    content_html: string;
+    correctness?: string;
+    feedback_html?: string;
+};
+export declare type Solution = {
+    images: any[];
+    solution_type: string;
+    content_html: string;
+};
+export declare type Question = {
+    id: number;
+    is_answer_order_important: boolean;
+    stimulus_html: string;
+    stem_html: string;
+    answers: Answer[];
+    hints: string[];
+    formats: string[];
+    combo_choices: any[];
+    collaborator_solutions?: Solution[];
+    community_solutions?: Solution[];
+};
+export declare type Exercise = {
+    images: any[];
+    tags: string[];
+    uuid: string;
+    group_uuid: string;
+    number: number;
+    version: number;
+    uid: string;
+    published_at: string;
+    solutions_are_public: boolean;
+    authors: any[];
+    copyright_holders: any[];
+    derived_from: any[];
+    is_vocab: boolean;
+    questions: Question[];
+    delegations: any[];
+    versions: number[];
+    stimulus_html: string;
+};
+export declare type ExercisesSearchResults = {
+    total_count: number;
+    items: Exercise[];
+};
+export declare type ExercisesSearchResultsWithDigest = ExercisesSearchResults & {
+    digest: string;
+};
+export declare const exercisesGateway: <C extends string = "exercises">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    defaultCorrectness?: import("../../config").ConfigValueProvider<string> | undefined;
+    exercisesHost: import("../../config").ConfigValueProvider<string>;
+    exercisesAuthToken: import("../../config").ConfigValueProvider<string>;
+}; }) => ({ profile }: {
+    profile: Track;
+}) => {
+    searchDigest: (query: string, page?: any, per_page?: any) => Promise<string>;
+    get: (uuid: string) => Promise<Exercise | undefined>;
+    search: (query: string, page?: any, per_page?: any) => Promise<ExercisesSearchResultsWithDigest>;
+};
+export declare type ExercisesGateway = ReturnType<ReturnType<ReturnType<typeof exercisesGateway>>>;
+export {};

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

@@ -0,0 +1,69 @@
+import * as queryString from 'query-string';
+import { once } from '../..';
+import { assertString } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+import { METHOD } from '../../routing';
+export const exercisesGateway = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'exercises')];
+    const exercisesHost = once(() => resolveConfigValue(config.exercisesHost));
+    const exercisesAuthToken = once(() => resolveConfigValue(config.exercisesAuthToken));
+    const defaultCorrectness = once(() => resolveConfigValue(config.defaultCorrectness || ''));
+    const doDefaultCorrectness = async (exercise) => {
+        if (await defaultCorrectness() !== 'true') {
+            return exercise;
+        }
+        for (const question of exercise.questions) {
+            const existingCorrect = question.answers.find(answer => answer.correctness !== undefined);
+            if (question.answers.length < 1 || existingCorrect) {
+                continue;
+            }
+            const defaultCorrectIndex = question.id % question.answers.length;
+            const defaultCorrect = question.answers[defaultCorrectIndex];
+            const defaultHint = `<em>random default: the correct answer is ${defaultCorrect.id}: ${defaultCorrect.content_html.slice(0, 20)}</em>`;
+            question.stem_html += `\n<br>${defaultHint}`;
+            question.collaborator_solutions = [
+                { solution_type: 'detailed', images: [], content_html: defaultHint }
+            ];
+            for (const [index, answer] of question.answers.entries()) {
+                answer.correctness = defaultCorrectIndex === index ? '1.0' : '0.0';
+                answer.feedback_html = defaultCorrectIndex === index ? 'This is the good one!' : defaultHint;
+            }
+        }
+        return exercise;
+    };
+    return ({ profile }) => {
+        const request = async (method, path, query = undefined) => {
+            const host = (await exercisesHost()).replace(/\/+$/, '');
+            const baseUrl = `${host}/api/${path}`;
+            const url = query ? `${baseUrl}?${queryString.stringify(query)}` : baseUrl;
+            return initializer.fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${await exercisesAuthToken()}`,
+                },
+                method,
+            });
+        };
+        const searchDigest = profile.track('searchExercisesDigest', () => async (query, page = 1, per_page = 100) => {
+            const response = await request(METHOD.HEAD, 'exercises', { query, page, per_page });
+            return assertString(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint HEAD did not return an X-Digest header');
+        });
+        const search = profile.track('searchExercises', () => async (query, page = 1, per_page = 100) => {
+            const response = await request(METHOD.GET, 'exercises', { query, page, per_page });
+            const digest = assertString(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint GET did not return an X-Digest header');
+            const { items, total_count } = await response.json();
+            return { digest, items: await Promise.all(items.map(doDefaultCorrectness)), total_count };
+        });
+        const get = profile.track('getExercise', () => async (uuid) => {
+            const response = await request(METHOD.GET, `exercises/${uuid}`);
+            return response.status === 404
+                ? undefined
+                : response.json().then(doDefaultCorrectness);
+        });
+        return {
+            searchDigest,
+            get,
+            search,
+        };
+    };
+};

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

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