@openstax/ts-utils 1.1.40 → 1.1.43

package/dist/esm/errors.d.ts

@@ -10,3 +10,7 @@ export declare class NotFoundError extends Error {
     static readonly TYPE = "NotFoundError";
     static matches: (e: any) => e is typeof NotFoundError;
 }
+export declare class SessionExpiredError extends Error {
+    static readonly TYPE = "SessionExpiredError";
+    static matches: (e: any) => e is typeof SessionExpiredError;
+}

package/dist/esm/errors.js

@@ -24,3 +24,7 @@ export class NotFoundError extends Error {
 }
 NotFoundError.TYPE = 'NotFoundError';
 NotFoundError.matches = errorIsType(NotFoundError);
+export class SessionExpiredError extends Error {
+}
+SessionExpiredError.TYPE = 'SessionExpiredError';
+SessionExpiredError.matches = errorIsType(SessionExpiredError);

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

@@ -2,6 +2,7 @@ import * as pathToRegexp from 'path-to-regexp';
 import queryString from 'query-string';
 import { merge } from '../..';
 import { resolveConfigValue } from '../../config';
+import { SessionExpiredError, UnauthorizedError } from '../../errors';
 export const loadResponse = (response) => () => {
     const [contentType] = (response.headers.get('content-type') || '').split(';');
     switch (contentType) {
@@ -31,16 +32,24 @@ const makeRouteClient = (initializer, config, route, authProvider) => {
                 ...fetchConfig === null || fetchConfig === void 0 ? void 0 : fetchConfig.headers,
                 ...(body ? { 'content-type': 'application/json' } : {}),
             }
-        })).then(response => ({
-            status: response.status,
-            acceptStatus: (...status) => {
-                if (!status.includes(response.status)) {
-                    throw new Error('unexpected response from api');
-                }
-                return { status: response.status, load: loadResponse(response) };
-            },
-            load: loadResponse(response),
-        }));
+        })).then(response => {
+            if (response.status === 401) {
+                throw new UnauthorizedError();
+            }
+            if (response.status === 440) {
+                throw new SessionExpiredError();
+            }
+            return {
+                status: response.status,
+                acceptStatus: (...status) => {
+                    if (!status.includes(response.status)) {
+                        throw new Error('unexpected response from api');
+                    }
+                    return { status: response.status, load: loadResponse(response) };
+                },
+                load: loadResponse(response),
+            };
+        });
     };
     routeClient.renderUrl = renderUrl;
     return routeClient;

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

@@ -1,6 +1,7 @@
 import * as crypto from 'crypto';
 import { TextEncoder } from 'util';
 import jwt from 'jsonwebtoken';
+import { SessionExpiredError } from '../../../errors';
 import { isPlainObject } from '../../../guards';
 const decrypt = (input, key) => {
     const splitInput = input.split('.');
@@ -22,7 +23,7 @@ export const decryptAndVerify = (token, encryptionPrivateKey, signaturePublicKey
         // Decrypt SSO cookie
         const plaintext = decrypt(token, encryptionPrivateKey);
         const payload = jwt.verify(plaintext, signaturePublicKey, {
-            clockTolerance: 300 // 5 minutes 
+            clockTolerance: 300 // 5 minutes
         });
         if (!isPlainObject(payload) || !isPlainObject(payload.sub) || !payload.sub.uuid) {
             return undefined;
@@ -30,7 +31,10 @@ export const decryptAndVerify = (token, encryptionPrivateKey, signaturePublicKey
         // TS is confused because the library types the `sub` as a string
         return payload.sub;
     }
-    catch {
+    catch (err) {
+        if (err instanceof jwt.TokenExpiredError) {
+            throw new SessionExpiredError();
+        }
         return undefined;
     }
 };

package/dist/esm/services/lrsGateway/attempt-utils.js

@@ -186,8 +186,7 @@ export const createAttemptStatement = (activity, parentActivity) => {
 };
 /* resolves with the statement id */
 export const putAttemptStatement = async (gateway, activity, parentActivity) => {
-    return await gateway.putXapiStatements([createAttemptStatement(activity, parentActivity)])
-        .then(statements => statements[0]);
+    return (await gateway.putXapiStatements([createAttemptStatement(activity, parentActivity)]))[0];
 };
 /*
  * creates a statement under the given attempt.
@@ -209,8 +208,7 @@ export const createAttemptActivityStatement = (attemptStatement, verb, result) =
     };
 };
 export const putAttemptActivityStatement = async (gateway, attemptStatement, verb, result) => {
-    return await gateway.putXapiStatements([createAttemptActivityStatement(attemptStatement, verb, result)])
-        .then(statements => statements[0]);
+    return (await gateway.putXapiStatements([createAttemptActivityStatement(attemptStatement, verb, result)]))[0];
 };
 /*
  * creates a statement that completes the given attempt.
@@ -246,6 +244,5 @@ export const createCompletedStatement = (attemptStatement, result) => {
     };
 };
 export const putCompletedStatement = async (gateway, attemptStatement, result) => {
-    return await gateway.putXapiStatements([createCompletedStatement(attemptStatement, result)])
-        .then(statements => statements[0]);
+    return (await gateway.putXapiStatements([createCompletedStatement(attemptStatement, result)]))[0];
 };

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

@@ -11,6 +11,7 @@ export const lrsGateway = (initializer) => (configProvider) => {
     const lrsHost = once(() => resolveConfigValue(config.lrsHost));
     const lrsAuthorization = once(() => resolveConfigValue(config.lrsAuthorization));
     return (authProvider) => {
+        // Note: This method actually uses POST
         const putXapiStatements = async (statements) => {
             const user = assertDefined(await authProvider.getUser(), new UnauthorizedError);
             const statementsWithDefaults = statements.map(statement => ({
@@ -24,7 +25,7 @@ export const lrsGateway = (initializer) => (configProvider) => {
                 },
                 timestamp: formatISO(new Date())
             }));
-            return initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements', {
+            const response = await initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements', {
                 body: JSON.stringify(statementsWithDefaults),
                 headers: {
                     Authorization: await lrsAuthorization(),
@@ -32,42 +33,50 @@ export const lrsGateway = (initializer) => (configProvider) => {
                     'X-Experience-API-Version': '1.0.0',
                 },
                 method: METHOD.POST,
-            })
-                .then(response => response.json())
-                .then(ids => ids.map((id, index) => ({ id, ...statementsWithDefaults[index] })));
+            });
+            if (![200, 201].includes(response.status)) {
+                throw new Error(`Unexpected LRS POST statements response code ${response.status} with body:
+
+${await response.text()}`);
+            }
+            const ids = await response.json();
+            return ids.map((id, index) => ({ id, ...statementsWithDefaults[index] }));
         };
-        const getMoreXapiStatements = async (more) => {
-            return initializer.fetch((await lrsHost()).replace(/\/+$/, '') + more, {
-                headers: {
-                    Authorization: await lrsAuthorization(),
-                    'X-Experience-API-Version': '1.0.0',
-                },
-            })
-                .then(response => response.json())
-                .then(json => json);
+        // Note: This code does not currently handle a single statement response,
+        // which can return 404 if the statement is not found
+        const formatGetXapiStatementsResponse = async (responsePromise) => {
+            const response = await responsePromise;
+            if (response.status !== 200) {
+                throw new Error(`Unexpected LRS GET statements response code ${response.status} with body:
+
+${await response.text()}`);
+            }
+            return response.json();
         };
-        const getXapiStatements = async ({ user, anyUser, ...options }) => {
-            return initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
-                ...options,
-                ...(anyUser === true ? {} : {
-                    agent: JSON.stringify({
-                        account: {
-                            homePage: 'https://openstax.org',
-                            name: user || assertDefined(await authProvider.getUser(), new UnauthorizedError()).uuid,
-                        },
-                        objectType: 'Agent',
-                    }),
-                })
-            }), {
-                headers: {
-                    Authorization: await lrsAuthorization(),
-                    'X-Experience-API-Version': '1.0.0',
-                },
+        const getMoreXapiStatements = async (more) => formatGetXapiStatementsResponse(initializer.fetch((await lrsHost()).replace(/\/+$/, '') + more, {
+            headers: {
+                Authorization: await lrsAuthorization(),
+                'X-Experience-API-Version': '1.0.0',
+            },
+        }));
+        const getXapiStatements = async ({ user, anyUser, ...options }) => formatGetXapiStatementsResponse(initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
+            ...options,
+            ...(anyUser === true ? {} : {
+                agent: JSON.stringify({
+                    account: {
+                        homePage: 'https://openstax.org',
+                        name: user || assertDefined(await authProvider.getUser(), new UnauthorizedError()).uuid,
+                    },
+                    objectType: 'Agent',
+                }),
             })
-                .then(response => response.json())
-                .then(json => json);
-        };
-        const getAllXapiStatements = (...args) => {
+        }), {
+            headers: {
+                Authorization: await lrsAuthorization(),
+                'X-Experience-API-Version': '1.0.0',
+            },
+        }));
+        const getAllXapiStatements = async (...args) => {
             const loadRemaining = async (result) => {
                 if (!result.more) {
                     return result.statements;
@@ -75,7 +84,7 @@ export const lrsGateway = (initializer) => (configProvider) => {
                 const { more, statements } = await getMoreXapiStatements(result.more);
                 return loadRemaining({ more, statements: [...result.statements, ...statements] });
             };
-            return getXapiStatements(...args).then(loadRemaining);
+            return loadRemaining(await getXapiStatements(...args));
         };
         return {
             putXapiStatements,

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

@@ -10,6 +10,10 @@ declare type Field = {
     key: string;
     type: 'keyword';
 };
+export interface IndexOptions<T> {
+    body: T;
+    id: string;
+}
 export interface SearchOptions {
     page?: number;
     query: string | undefined;

package/dist/esm/services/searchProvider/memorySearchTheBadWay.d.ts

@@ -1,7 +1,8 @@
-import { SearchOptions } from '.';
+import { IndexOptions, SearchOptions } from '.';
 export declare const memorySearchTheBadWay: <T>({ loadAllDocumentsTheBadWay }: {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
 }) => {
+    index: (_options: IndexOptions<T>) => Promise<undefined>;
     search: (options: SearchOptions) => Promise<{
         items: T[];
         pageSize: number;

package/dist/esm/services/searchProvider/memorySearchTheBadWay.js

@@ -5,6 +5,7 @@ const MAX_RESULTS = 10;
 const resolveField = (document, field) => field.key.toString().split('.').reduce((result, key) => result[key], document);
 export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
     return {
+        index: async (_options) => undefined,
         search: async (options) => {
             const results = (await loadAllDocumentsTheBadWay())
                 .map(document => {