@openstax/ts-utils 1.20.3 → 1.20.4

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

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

package/dist/cjs/fetch/fetchStatusRetry.js

@@ -1,24 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchStatusRetry = void 0;
+const helpers_1 = require("../misc/helpers");
 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);
+    return (...params) => (0, helpers_1.retryWithDelay)(() => base(...params).then(r => {
+        var _a;
+        if ((_a = options.status) === null || _a === void 0 ? void 0 : _a.includes(r.status)) {
+            return r.text().then(text => {
+                throw new Error(`fetch failed ${params[0]} -- ${r.status}: ${text}`);
+            });
+        }
+        return r;
+    }), options);
 };
 exports.fetchStatusRetry = fetchStatusRetry;

package/dist/cjs/misc/helpers.d.ts

@@ -1,3 +1,4 @@
+import type { Logger } from '../services/logger';
 /**
  * Returns a function that gets the value of the given key from an object
  *
@@ -44,7 +45,8 @@ declare type FlowChainArg<C> = C extends [infer F1, ...infer _] ? F1 extends Flo
  * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
  */
 export declare const flow: <C extends AnyFlowFn[]>(...chain: C) => (param: FlowChainArg<C>) => FlowResult<C, FlowChainArg<C>>;
-declare type RetryOptions = {
+export declare type RetryOptions = {
+    logger?: Logger;
     wait?: number;
     splay?: number;
     retries?: number;
@@ -64,7 +66,7 @@ declare type RetryOptions = {
  *  initial wait cliff with incremental increases, then maybe you'd set this. default: 0
  * @returns A promise that resolves with the result of the function, or rejects with the last error.
  */
-export declare const retryWithDelay: <R>(fn: () => Promise<R>, options?: RetryOptions | undefined) => Promise<R>;
+export declare const retryWithDelay: <R>(fn: (abort?: ((e: Error) => never) | undefined) => Promise<R>, options?: RetryOptions | undefined) => Promise<R>;
 /**
  * a shameful helper to avoid needing to test code coverage of branches
  */

package/dist/cjs/misc/helpers.js

@@ -1,10 +1,10 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tuple = exports.roundToPrecision = exports.memoize = exports.once = exports.mapFind = exports.fnIf = exports.retryWithDelay = exports.flow = exports.coerceArray = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
 /*
  * there was a reason i made these instead of using lodash/fp but i forget what it was. i think maybe
  * these do more validation that the second function gets a compatible object.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tuple = exports.roundToPrecision = exports.memoize = exports.once = exports.mapFind = exports.fnIf = exports.retryWithDelay = exports.flow = exports.coerceArray = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
 /**
  * Returns a function that gets the value of the given key from an object
  *
@@ -76,11 +76,23 @@ const retryWithDelay = (fn, options) => {
     if (n >= retries) {
         return fn();
     }
+    let aborted = false;
     const timeout = (n + 1) * wait + (Math.random() * 2 - 1) * splay * wait;
-    const retry = () => new Promise((resolve, reject) => {
-        setTimeout(() => (0, exports.retryWithDelay)(fn, { ...options, n: n + 1 }).then(resolve, reject), timeout);
+    const retry = (e) => new Promise((resolve, reject) => {
+        var _a;
+        if (aborted) {
+            reject(e);
+        }
+        else {
+            (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.log(`failed try ${n} of ${retries}. ${e.message}`);
+            setTimeout(() => (0, exports.retryWithDelay)(fn, { ...options, n: n + 1 }).then(resolve, reject), timeout);
+        }
     });
-    return fn().catch(retry);
+    const abort = (e) => {
+        aborted = true;
+        throw e;
+    };
+    return fn(abort).catch(retry);
 };
 exports.retryWithDelay = retryWithDelay;
 /**

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

@@ -58,7 +58,7 @@ const makeRouteClient = (initializer, config, route, authProvider) => {
         const url = await renderUrl({ params, query });
         const body = payload ? JSON.stringify(payload) : undefined;
         const baseOptions = (0, __1.merge)((await (authProvider === null || authProvider === void 0 ? void 0 : authProvider.getAuthorizedFetchConfig())) || {}, fetchConfig || {});
-        const fetcher = (0, fetchStatusRetry_1.fetchStatusRetry)(initializer.fetch, { retries: 1, status: [502], onFail: true });
+        const fetcher = (0, fetchStatusRetry_1.fetchStatusRetry)(initializer.fetch, { retries: 1, status: [502] });
         return fetcher(url, (0, __1.merge)(baseOptions, {
             method: route.method,
             body,

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

@@ -12,7 +12,7 @@ const decryptionAuthProvider = (initializer) => (configProvider) => {
     const cookieName = (0, helpers_1.once)(() => (0, resolveConfigValue_1.resolveConfigValue)(config.cookieName));
     const encryptionPrivateKey = (0, helpers_1.once)(() => (0, resolveConfigValue_1.resolveConfigValue)(config.encryptionPrivateKey));
     const signaturePublicKey = (0, helpers_1.once)(() => (0, resolveConfigValue_1.resolveConfigValue)(config.signaturePublicKey));
-    return ({ request }) => {
+    return ({ request, logger }) => {
         let user;
         const getAuthorizedFetchConfig = async () => {
             const [token, headers] = (0, _1.getAuthTokenOrCookie)(request, await cookieName());
@@ -36,7 +36,11 @@ const decryptionAuthProvider = (initializer) => (configProvider) => {
             if ('error' in result && result.error == 'expired token') {
                 throw new errors_1.SessionExpiredError();
             }
-            return 'user' in result ? result.user : undefined;
+            if ('user' in result) {
+                logger.setContext({ user: result.user.uuid });
+                return result.user;
+            }
+            return undefined;
         };
         return {
             getAuthorizedFetchConfig,

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

@@ -1,5 +1,6 @@
 import type { FetchConfig } from '../../fetch';
 import type { HttpHeaders, QueryParams } from '../../routing';
+import type { Logger } from '../logger';
 export declare type ConsentPreferences = {
     consent_preferences: {
         accepted: string[];
@@ -49,6 +50,7 @@ export declare type CookieAuthProviderRequest = {
 };
 export declare type CookieAuthProvider<T extends AuthProvider = AuthProvider> = (inputs: {
     request: CookieAuthProviderRequest;
+    logger: Logger;
 }) => T;
 export declare type StubAuthProvider = (user: User | undefined) => AuthProvider;
 export declare const stubAuthProvider: (user?: User | undefined) => AuthProvider;

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

@@ -13,7 +13,7 @@ const subrequestAuthProvider = (initializer) => (configProvider) => {
     const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'subrequest')];
     const cookieName = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.cookieName));
     const accountsBase = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.accountsBase));
-    return ({ request }) => {
+    return ({ request, logger }) => {
         let user;
         const getAuthorizedFetchConfig = async () => {
             const [token, headers] = (0, _1.getAuthTokenOrCookie)(request, await cookieName());
@@ -29,8 +29,12 @@ const subrequestAuthProvider = (initializer) => (configProvider) => {
                 return undefined;
             }
             const headers = { cookie: cookie_1.default.serialize(resolvedCookieName, token) };
-            return initializer.fetch((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
+            const user = await initializer.fetch((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
                 .then(response => response.json());
+            if (user) {
+                logger.setContext({ user: user.uuid });
+            }
+            return user;
         };
         return {
             getAuthorizedFetchConfig,

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

@@ -2,6 +2,7 @@ import { ConfigProviderForConfig } from '../../config';
 import { GenericFetch } from '../../fetch';
 import { WithRequired } from '../../types';
 import { AuthProvider } from '../authProvider';
+import { Logger } from '../logger';
 declare type Config = {
     lrsHost: string;
     lrsAuthorization: string;
@@ -80,7 +81,10 @@ export declare type LrsProvider = ReturnType<ReturnType<typeof lrsGateway>>;
 export declare const lrsGateway: <C extends string = "lrs">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
     lrsHost: import("../../config").ConfigValueProvider<string>;
     lrsAuthorization: import("../../config").ConfigValueProvider<string>;
-}; }) => (authProvider: AuthProvider) => {
+}; }) => ({ authProvider, logger }: {
+    authProvider: AuthProvider;
+    logger: Logger;
+}) => {
     putXapiStatements: (statements: Array<(Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
         id?: string;
     }) | UXapiStatement>) => Promise<EagerXapiStatement[]>;

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

@@ -31,14 +31,20 @@ const config_1 = require("../../config");
 const errors_1 = require("../../errors");
 const fetchStatusRetry_1 = require("../../fetch/fetchStatusRetry");
 const guards_1 = require("../../guards");
+const helpers_1 = require("../../misc/helpers");
 const routing_1 = require("../../routing");
 const addStatementDefaultFields_1 = require("./addStatementDefaultFields");
 const lrsGateway = (initializer) => (configProvider) => {
     const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'lrs')];
     const lrsHost = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.lrsHost));
     const lrsAuthorization = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.lrsAuthorization));
-    const fetcher = (0, fetchStatusRetry_1.fetchStatusRetry)(initializer.fetch, { retries: 1, status: [502], onFail: true });
-    return (authProvider) => {
+    return ({ authProvider, logger }) => {
+        const fetcher = (0, fetchStatusRetry_1.fetchStatusRetry)(initializer.fetch, {
+            logger,
+            retries: 2,
+            wait: 1000,
+            status: [502]
+        });
         // Note: This method actually uses POST
         const putXapiStatements = async (statements) => {
             const user = (0, assertions_1.assertDefined)(await authProvider.getUser(), new errors_1.UnauthorizedError);
@@ -62,8 +68,7 @@ ${await response.text()}`);
         };
         // 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;
+        const formatGetXapiStatementsResponse = async (response) => {
             if (response.status !== 200) {
                 throw new Error(`Unexpected LRS GET statements response code ${response.status} with body:
 
@@ -71,12 +76,12 @@ ${await response.text()}`);
             }
             return response.json();
         };
-        const getMoreXapiStatements = async (more) => formatGetXapiStatementsResponse(fetcher((await lrsHost()).replace(/\/+$/, '') + more, {
+        const getMoreXapiStatements = async (more) => fetcher((await lrsHost()).replace(/\/+$/, '') + more, {
             headers: {
                 Authorization: await lrsAuthorization(),
                 'X-Experience-API-Version': '1.0.0',
             },
-        }));
+        }).then(formatGetXapiStatementsResponse);
         const fetchXapiStatements = async ({ user, anyUser, ...options }) => fetcher((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
             ...options,
             ...(anyUser === true ? {} : {
@@ -98,18 +103,18 @@ ${await response.text()}`);
             const { ensureSync, ...fetchParams } = params;
             if (ensureSync) {
                 const date = new Date();
-                return (0, __1.retryWithDelay)(async () => {
-                    const responsePromise = fetchXapiStatements(fetchParams);
-                    const response = await responsePromise;
+                return (0, helpers_1.retryWithDelay)(async (abort) => {
+                    // this function retries for the consistency, if the fetch errors just abort
+                    const response = await fetchXapiStatements(fetchParams).catch(abort);
                     const consistentThrough = response.headers.get('X-Experience-API-Consistent-Through');
                     if (!consistentThrough || new Date(consistentThrough) < date) {
                         throw new Error(`xAPI consistent through ${consistentThrough}; not in sync with current date ${date}.`);
                     }
-                    return formatGetXapiStatementsResponse(responsePromise);
-                }, { retries: 4 });
+                    return formatGetXapiStatementsResponse(response);
+                }, { retries: 4, logger });
             }
             else {
-                return formatGetXapiStatementsResponse(fetchXapiStatements(fetchParams));
+                return fetchXapiStatements(fetchParams).then(formatGetXapiStatementsResponse);
             }
         };
         const getAllXapiStatements = async ({ fetchUntil, ...params }) => {