@openstax/ts-utils 1.20.1 → 1.20.3

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

@@ -80,6 +80,8 @@ export declare const mapFind: <I, R>(array: I[], mapper: (item: I) => R, predica
 /**
  * returns a function that will only ever call the given function once, returning the first result for every subsequent call
  *
+ * does not cache rejected promises, to avoid cache poisoning on failed async requests
+ *
  * eg:
  *   const heavyFunction = () => 'hello';
  *   const butOnlyOnce = once(() => 'hello');
@@ -90,6 +92,8 @@ export declare const mapFind: <I, R>(array: I[], mapper: (item: I) => R, predica
 export declare const once: <F extends (...args: any[]) => any>(fn: F) => F;
 /**
  * memoizes a function with any number of arguments
+ *
+ * does not cache rejected promises, to avoid cache poisoning on failed async requests
  */
 export declare const memoize: <F extends (...args: any[]) => any>(fn: F) => F;
 /**

package/dist/esm/misc/helpers.js

@@ -96,6 +96,8 @@ export const mapFind = (array, mapper, predicate = (r) => !!r) => {
 /**
  * returns a function that will only ever call the given function once, returning the first result for every subsequent call
  *
+ * does not cache rejected promises, to avoid cache poisoning on failed async requests
+ *
  * eg:
  *   const heavyFunction = () => 'hello';
  *   const butOnlyOnce = once(() => 'hello');
@@ -121,6 +123,8 @@ export const once = (fn) => {
 };
 /**
  * memoizes a function with any number of arguments
+ *
+ * does not cache rejected promises, to avoid cache poisoning on failed async requests
  */
 export const memoize = (fn) => {
     const cache = {};
@@ -143,7 +147,15 @@ export const memoize = (fn) => {
     };
     return ((...args) => {
         const thisCache = resolveCache(cache, args);
-        return thisCache.result = (thisCache.result || fn(...args));
+        if ('result' in thisCache) {
+            return thisCache.result;
+        }
+        thisCache.result = fn(...args);
+        if (typeof thisCache.result === 'object' && thisCache.result instanceof Promise) {
+            // Clear the result when possible but do not return a Promise that resolves to the initialValue
+            thisCache.result.catch(() => delete thisCache.result);
+        }
+        return thisCache.result;
     });
 };
 /**

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

@@ -1,5 +1,5 @@
-import { XapiStatement, EagerXapiStatement } from ".";
-import { User } from "../authProvider";
-export declare const addStatementDefaultFields: (statement: Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+import { User } from '../authProvider';
+import { EagerXapiStatement, UXapiStatement, XapiStatement } from '.';
+export declare const addStatementDefaultFields: (statement: (Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
     id?: string;
-}, user: User) => EagerXapiStatement;
+}) | UXapiStatement, user: User) => EagerXapiStatement;

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

@@ -2,7 +2,6 @@ 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',
@@ -10,5 +9,6 @@ export const addStatementDefaultFields = (statement, user) => ({
         },
         objectType: 'Agent',
     },
-    timestamp: formatISO(new Date())
+    timestamp: formatISO(new Date()),
+    ...statement,
 });

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

@@ -1,23 +1,23 @@
-import { LrsGateway, XapiStatement } from '.';
+import { LrsGateway, UXapiStatement } from '.';
 export declare type ActivityState = {
     attempts: number;
     completedAttempts: number;
-    currentAttempt?: XapiStatement;
-    currentAttemptCompleted?: XapiStatement;
-    currentAttemptStatements: XapiStatement[];
-    mostRecentAttemptWithCompleted?: XapiStatement;
-    mostRecentAttemptWithCompletedCompleted?: XapiStatement;
+    currentAttempt?: UXapiStatement;
+    currentAttemptCompleted?: UXapiStatement;
+    currentAttemptStatements: UXapiStatement[];
+    mostRecentAttemptWithCompleted?: UXapiStatement;
+    mostRecentAttemptWithCompletedCompleted?: UXapiStatement;
 };
-export declare const matchAttempt: (statement: XapiStatement) => boolean;
-export declare const matchAttemptCompleted: (attempt: XapiStatement) => (statement: XapiStatement) => boolean;
-export declare const resolveAttempts: (statements: XapiStatement[], options?: {
+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 | undefined;
     parentActivityAttempt?: string | undefined;
-} | undefined) => XapiStatement[];
-export declare const resolveCompletedForAttempt: (statements: XapiStatement[], attempt: XapiStatement, activityIRI?: string | undefined) => XapiStatement | undefined;
-export declare const oldestStatement: (statements: XapiStatement[]) => XapiStatement | undefined;
-export declare const mostRecentStatement: (statements: XapiStatement[]) => XapiStatement | undefined;
-export declare const resolveAttemptInfo: (statements: XapiStatement[], options?: {
+} | undefined) => UXapiStatement[];
+export declare const resolveCompletedForAttempt: (statements: UXapiStatement[], attempt: UXapiStatement, activityIRI?: string | undefined) => 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 | undefined;
     currentAttempt?: string | undefined;
     parentActivityAttempt?: string | undefined;
@@ -28,20 +28,20 @@ export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGat
     attempt?: string | undefined;
     ensureSync?: boolean | undefined;
     user?: string | undefined;
-} | undefined) => Promise<XapiStatement[]>;
+} | undefined) => Promise<import(".").XapiStatement[]>;
 export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
     currentAttempt?: string | undefined;
     parentActivityAttempt?: string | undefined;
     ensureSync?: boolean | undefined;
 } | undefined) => Promise<ActivityState>;
-export declare const createStatement: (verb: XapiStatement['verb'], activity: {
+export declare const createStatement: (verb: UXapiStatement['verb'], activity: {
     iri: string;
     type: string;
     name: string;
     extensions?: {
         [key: string]: string;
     } | undefined;
-}, attempt: string, parentActivityIRI?: string | undefined) => Pick<XapiStatement, 'object' | 'verb' | 'context'>;
+}, attempt: string, parentActivityIRI?: string | undefined) => Pick<UXapiStatement, 'object' | 'verb' | 'context'>;
 export declare const createAttemptStatement: (activity: {
     iri: string;
     type: string;
@@ -52,7 +52,7 @@ export declare const createAttemptStatement: (activity: {
 }, parentActivity?: {
     iri?: string | undefined;
     attempt?: string | undefined;
-} | undefined) => Pick<XapiStatement, 'object' | 'verb' | 'context'>;
+} | undefined) => Pick<UXapiStatement, 'object' | 'verb' | 'context'>;
 export declare const putAttemptStatement: (gateway: LrsGateway, activity: {
     iri: string;
     type: string;
@@ -64,7 +64,7 @@ export declare const putAttemptStatement: (gateway: LrsGateway, activity: {
     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>;
+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>;

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

@@ -32,8 +32,8 @@ export const resolveAttempts = (statements, options) => statements.filter(statem
 });
 export const resolveCompletedForAttempt = (statements, attempt, activityIRI) => statements.find(statement => matchAttemptCompleted(attempt)(statement)
     && (!activityIRI || statement.object.id === activityIRI));
-export const oldestStatement = (statements) => statements.reduce((result, statement) => result && isBefore(parseISO(result.stored || result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
-export const mostRecentStatement = (statements) => statements.reduce((result, statement) => result && isAfter(parseISO(result.stored || result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
+export const oldestStatement = (statements) => statements.reduce((result, statement) => result && isBefore(parseISO('stored' in result && result.stored ? result.stored : result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
+export const mostRecentStatement = (statements) => statements.reduce((result, statement) => result && isAfter(parseISO('stored' in result && result.stored ? result.stored : result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
 export const resolveAttemptInfo = (statements, options) => {
     // TODO optimize. i'm 100% that this could all be done in one iteration but i'm not messing around with that for now.
     const attempts = resolveAttempts(statements, options);

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

@@ -74,6 +74,7 @@ export interface XapiStatement {
 }
 export declare type SavedXapiStatement = WithRequired<XapiStatement, 'stored'>;
 export declare type EagerXapiStatement = Omit<XapiStatement, 'stored'>;
+export declare type UXapiStatement = XapiStatement | EagerXapiStatement | SavedXapiStatement;
 export declare type LrsGateway = ReturnType<ReturnType<ReturnType<typeof lrsGateway>>>;
 export declare type LrsProvider = ReturnType<ReturnType<typeof lrsGateway>>;
 export declare const lrsGateway: <C extends string = "lrs">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
@@ -82,7 +83,7 @@ export declare const lrsGateway: <C extends string = "lrs">(initializer: Initial
 }; }) => (authProvider: AuthProvider) => {
     putXapiStatements: (statements: Array<(Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
         id?: string;
-    }) | EagerXapiStatement>) => Promise<EagerXapiStatement[]>;
+    }) | UXapiStatement>) => Promise<EagerXapiStatement[]>;
     getXapiStatements: (params: {
         verb?: string | undefined;
         activity?: string | undefined;

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

@@ -6,7 +6,7 @@ import { UnauthorizedError } from '../../errors';
 import { fetchStatusRetry } from '../../fetch/fetchStatusRetry';
 import { ifDefined } from '../../guards';
 import { METHOD } from '../../routing';
-import { addStatementDefaultFields } from "./addStatementDefaultFields";
+import { addStatementDefaultFields } from './addStatementDefaultFields';
 export const lrsGateway = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'lrs')];
     const lrsHost = once(() => resolveConfigValue(config.lrsHost));