@openstax/ts-utils 1.2.4 → 1.2.6

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

@@ -19,12 +19,21 @@ export declare const resolveActivityAttemptInfo: (statements: XapiStatement[], a
     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 loadStatementsForActivityAndFirstChildren: (gateway: LrsGateway, activityIRI: string, options?: {
+    attempt?: string | undefined;
+    ensureSync?: boolean | undefined;
+} | undefined) => Promise<XapiStatement[]>;
+export declare const loadStatementsForAttempt: (gateway: LrsGateway, attempt: string, options?: {
+    ensureSync?: boolean | undefined;
+} | undefined) => Promise<XapiStatement[]>;
+export declare const loadStatementsForActivity: (gateway: LrsGateway, activityIRI: string, options?: {
+    attempt?: string | undefined;
+    ensureSync?: boolean | undefined;
+} | undefined) => Promise<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: {
     iri: string;

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

@@ -78,32 +78,39 @@ export const resolveActivityAttemptInfo = (statements, activityIRI, options) =>
  * statements would then have to be fetched using `loadStatementsForActivity(gateway, childActivityIRI, childAttemptStatementID)`. this
  * is because child activities could have multiple attempts under one attempt on the parent activity.
  */
-export const loadStatementsForActivityAndFirstChildren = (gateway, activityIRI, attempt) => {
+export const loadStatementsForActivityAndFirstChildren = (gateway, activityIRI, options) => {
+    const { attempt, ...partialOptions } = options ? options : { attempt: undefined };
+    const getOptions = attempt ? { registration: attempt, ...partialOptions } : partialOptions;
     return gateway.getAllXapiStatements({
         activity: activityIRI,
         related_activities: true,
-        ...(attempt ? { registration: attempt } : {})
+        ...getOptions,
     });
 };
 /*
  * loads all statements (for this actor) that have the given parent attempt (registration)
  */
-export const loadStatementsForAttempt = (gateway, attempt) => {
+export const loadStatementsForAttempt = (gateway, attempt, options) => {
     return gateway.getAllXapiStatements({
-        registration: attempt
+        registration: attempt,
+        ...(options ? options : {})
     });
 };
 /*
  * loads all statements (for this actor) that have the given activityIRI as the object.id
  */
-export const loadStatementsForActivity = (gateway, activityIRI, attempt) => {
+export const loadStatementsForActivity = (gateway, activityIRI, options) => {
+    const { attempt, ...partialOptions } = options ? options : { attempt: undefined };
+    const getOptions = attempt ? { registration: attempt, ...partialOptions } : partialOptions;
     return gateway.getAllXapiStatements({
         activity: activityIRI,
-        ...(attempt ? { registration: attempt } : {})
+        ...getOptions,
     });
 };
 export const loadActivityAttemptInfo = async (gateway, activityIRI, options) => {
-    return resolveActivityAttemptInfo(await loadStatementsForActivity(gateway, activityIRI, options === null || options === void 0 ? void 0 : options.parentActivityAttempt), activityIRI, options);
+    const { parentActivityAttempt, ...partialOptions } = options ? options : { parentActivityAttempt: undefined };
+    const loadOptions = parentActivityAttempt ? { attempt: parentActivityAttempt } : partialOptions;
+    return resolveActivityAttemptInfo(await loadStatementsForActivity(gateway, activityIRI, loadOptions), activityIRI, options);
 };
 export const createStatement = (verb, activity, attempt, parentActivityIRI) => {
     return {

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

@@ -83,13 +83,15 @@ export declare const lrsGateway: <C extends string = "lrs">(initializer: Initial
     putXapiStatements: (statements: Array<Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
         id?: string;
     }>) => Promise<EagerXapiStatement[]>;
-    getXapiStatements: ({ user, anyUser, ...options }: {
+    getXapiStatements: (params: {
         verb?: string | undefined;
         activity?: string | undefined;
         registration?: string | undefined;
         related_activities?: boolean | undefined;
         user?: string | undefined;
         anyUser?: boolean | undefined;
+    } & {
+        ensureSync?: boolean | undefined;
     }) => Promise<{
         more: string;
         statements: XapiStatement[];
@@ -98,13 +100,15 @@ export declare const lrsGateway: <C extends string = "lrs">(initializer: Initial
         more: string;
         statements: XapiStatement[];
     }>;
-    getAllXapiStatements: (args_0: {
+    getAllXapiStatements: (params: {
         verb?: string | undefined;
         activity?: string | undefined;
         registration?: string | undefined;
         related_activities?: boolean | undefined;
         user?: string | undefined;
         anyUser?: boolean | undefined;
+    } & {
+        ensureSync?: boolean | undefined;
     }) => Promise<XapiStatement[]>;
 };
 export {};

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

@@ -1,6 +1,6 @@
 import formatISO from 'date-fns/formatISO';
 import * as queryString from 'query-string';
-import { once } from '../..';
+import { once, retryWithDelay } from '../..';
 import { assertDefined } from '../../assertions';
 import { resolveConfigValue } from '../../config';
 import { UnauthorizedError } from '../../errors';
@@ -59,7 +59,7 @@ ${await response.text()}`);
                 'X-Experience-API-Version': '1.0.0',
             },
         }));
-        const getXapiStatements = async ({ user, anyUser, ...options }) => formatGetXapiStatementsResponse(initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
+        const fetchXapiStatements = async ({ user, anyUser, ...options }) => initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
             ...options,
             ...(anyUser === true ? {} : {
                 agent: JSON.stringify({
@@ -75,8 +75,26 @@ ${await response.text()}`);
                 Authorization: await lrsAuthorization(),
                 'X-Experience-API-Version': '1.0.0',
             },
-        }));
-        const getAllXapiStatements = async (...args) => {
+        });
+        const getXapiStatements = async (params) => {
+            const { ensureSync, ...fetchParams } = params;
+            if (ensureSync) {
+                const date = new Date();
+                return retryWithDelay(async () => {
+                    const responsePromise = fetchXapiStatements(fetchParams);
+                    const response = await responsePromise;
+                    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);
+                });
+            }
+            else {
+                return formatGetXapiStatementsResponse(fetchXapiStatements(fetchParams));
+            }
+        };
+        const getAllXapiStatements = async (params) => {
             const loadRemaining = async (result) => {
                 if (!result.more) {
                     return result.statements;
@@ -84,7 +102,7 @@ ${await response.text()}`);
                 const { more, statements } = await getMoreXapiStatements(result.more);
                 return loadRemaining({ more, statements: [...result.statements, ...statements] });
             };
-            return loadRemaining(await getXapiStatements(...args));
+            return loadRemaining(await getXapiStatements(params));
         };
         return {
             putXapiStatements,