@openstax/ts-utils 1.19.0 → 1.20.1

package/dist/esm/fetch/fetchStatusRetry.d.ts

@@ -0,0 +1,8 @@
+import { GenericFetch } from '.';
+interface Options {
+    status?: number[];
+    onFail?: boolean;
+    retries: number;
+}
+export declare const fetchStatusRetry: (base: GenericFetch, options: Options) => GenericFetch;
+export {};

package/dist/esm/fetch/fetchStatusRetry.js

@@ -0,0 +1,20 @@
+export const fetchStatusRetry = (base, options) => {
+    const fetchTry = (retries, ...params) => {
+        return base(...params)
+            .catch(e => options.onFail && retries > 0
+            ? fetchTry(retries - 1, ...params)
+            : Promise.reject(e))
+            .then(async (r) => {
+            var _a;
+            const shouldHandleStatus = (_a = options.status) === null || _a === void 0 ? void 0 : _a.includes(r.status);
+            if (shouldHandleStatus && retries > 0) {
+                return fetchTry(retries - 1, ...params);
+            }
+            else if (shouldHandleStatus) {
+                throw new Error(`fetch failed after ${options.retries} retries. ${params[0]} -- ${r.status}: ${await r.text()}`);
+            }
+            return r;
+        });
+    };
+    return (...params) => fetchTry(options.retries, ...params);
+};

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

@@ -3,6 +3,7 @@ import queryString from 'query-string';
 import { merge } from '../..';
 import { resolveConfigValue } from '../../config';
 import { SessionExpiredError, UnauthorizedError } from '../../errors';
+import { fetchStatusRetry } from '../../fetch/fetchStatusRetry';
 /** Pulls the content out of a response based on the content type */
 export const loadResponse = (response) => () => {
     const [contentType] = (response.headers.get('content-type') || '').split(';');
@@ -27,7 +28,8 @@ const makeRouteClient = (initializer, config, route, authProvider) => {
         const url = await renderUrl({ params, query });
         const body = payload ? JSON.stringify(payload) : undefined;
         const baseOptions = merge((await (authProvider === null || authProvider === void 0 ? void 0 : authProvider.getAuthorizedFetchConfig())) || {}, fetchConfig || {});
-        return initializer.fetch(url, merge(baseOptions, {
+        const fetcher = fetchStatusRetry(initializer.fetch, { retries: 1, status: [502], onFail: true });
+        return fetcher(url, merge(baseOptions, {
             method: route.method,
             body,
             headers: {

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

@@ -0,0 +1,5 @@
+import { XapiStatement, EagerXapiStatement } from ".";
+import { User } from "../authProvider";
+export declare const addStatementDefaultFields: (statement: Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+    id?: string;
+}, 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(),
+    ...statement,
+    actor: {
+        account: {
+            homePage: 'https://openstax.org',
+            name: user.uuid,
+        },
+        objectType: 'Agent',
+    },
+    timestamp: formatISO(new Date())
+});

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

@@ -80,9 +80,9 @@ export declare const lrsGateway: <C extends string = "lrs">(initializer: Initial
     lrsHost: import("../../config").ConfigValueProvider<string>;
     lrsAuthorization: import("../../config").ConfigValueProvider<string>;
 }; }) => (authProvider: AuthProvider) => {
-    putXapiStatements: (statements: Array<Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+    putXapiStatements: (statements: Array<(Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
         id?: string;
-    }>) => Promise<EagerXapiStatement[]>;
+    }) | EagerXapiStatement>) => Promise<EagerXapiStatement[]>;
     getXapiStatements: (params: {
         verb?: string | undefined;
         activity?: string | undefined;

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

@@ -1,31 +1,23 @@
-import formatISO from 'date-fns/formatISO';
 import * as queryString from 'query-string';
 import { once, retryWithDelay } from '../..';
 import { assertDefined } from '../../assertions';
 import { resolveConfigValue } from '../../config';
 import { UnauthorizedError } from '../../errors';
+import { fetchStatusRetry } from '../../fetch/fetchStatusRetry';
 import { ifDefined } from '../../guards';
 import { METHOD } from '../../routing';
+import { addStatementDefaultFields } from "./addStatementDefaultFields";
 export const lrsGateway = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'lrs')];
     const lrsHost = once(() => resolveConfigValue(config.lrsHost));
     const lrsAuthorization = once(() => resolveConfigValue(config.lrsAuthorization));
+    const fetcher = fetchStatusRetry(initializer.fetch, { retries: 1, status: [502], onFail: true });
     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 => ({
-                ...statement,
-                actor: {
-                    account: {
-                        homePage: 'https://openstax.org',
-                        name: user.uuid,
-                    },
-                    objectType: 'Agent',
-                },
-                timestamp: formatISO(new Date())
-            }));
-            const response = await initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements', {
+            const statementsWithDefaults = statements.map(statement => addStatementDefaultFields(statement, user));
+            const response = await fetcher((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements', {
                 body: JSON.stringify(statementsWithDefaults),
                 headers: {
                     Authorization: await lrsAuthorization(),
@@ -39,8 +31,8 @@ export const lrsGateway = (initializer) => (configProvider) => {
 
 ${await response.text()}`);
             }
-            const ids = await response.json();
-            return ids.map((id, index) => ({ id, ...statementsWithDefaults[index] }));
+            await response.json();
+            return statementsWithDefaults;
         };
         // Note: This code does not currently handle a single statement response,
         // which can return 404 if the statement is not found
@@ -53,13 +45,13 @@ ${await response.text()}`);
             }
             return response.json();
         };
-        const getMoreXapiStatements = async (more) => formatGetXapiStatementsResponse(initializer.fetch((await lrsHost()).replace(/\/+$/, '') + more, {
+        const getMoreXapiStatements = async (more) => formatGetXapiStatementsResponse(fetcher((await lrsHost()).replace(/\/+$/, '') + more, {
             headers: {
                 Authorization: await lrsAuthorization(),
                 'X-Experience-API-Version': '1.0.0',
             },
         }));
-        const fetchXapiStatements = async ({ user, anyUser, ...options }) => initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
+        const fetchXapiStatements = async ({ user, anyUser, ...options }) => fetcher((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
             ...options,
             ...(anyUser === true ? {} : {
                 agent: JSON.stringify({