@openstax/ts-utils 1.2.3 → 1.2.5

package/dist/esm/middleware/lambdaCorsResponseMiddleware.js

@@ -3,7 +3,7 @@ import { apiTextResponse } from '../routing';
 export const createLambdaCorsResponseMiddleware = (config) => (responsePromise, { request }) => {
     const cors = async () => {
         const allowedHost = await resolveConfigValue(config.corsAllowedHostRegex);
-        if (request.headers.origin && new URL(request.headers.origin).hostname.match(new RegExp(allowedHost))) {
+        if (request.headers.origin && request.headers.origin !== 'null' && new URL(request.headers.origin).hostname.match(new RegExp(allowedHost))) {
             return {
                 'Access-Control-Allow-Origin': request.headers.origin,
                 'Access-Control-Allow-Credentials': 'true',

package/dist/esm/services/authProvider/browser.d.ts

@@ -48,7 +48,9 @@ export declare const browserAuthProvider: <C extends string = "auth">({ window,
      * gets an authorized url for an iframe src. sets params on the url and saves its
      * origin to trust releasing user identity to it
      */
-    getAuthorizedEmbedUrl: (urlString: string) => string;
+    getAuthorizedEmbedUrl: (urlString: string, extraParams?: {
+        [key: string]: string;
+    } | undefined) => string;
     /**
      * gets second argument for `fetch` that has authentication token or cookie
      */

package/dist/esm/services/authProvider/utils/embeddedAuthProvider.d.ts

@@ -14,7 +14,9 @@ export declare const embeddedAuthProvider: (getUserData: UserDataLoader, { query
     window: Window;
 }) => {
     embeddedQueryValue: string;
-    getAuthorizedEmbedUrl: (urlString: string) => string;
+    getAuthorizedEmbedUrl: (urlString: string, extraParams?: {
+        [key: string]: string;
+    } | undefined) => string;
     unmount: () => void;
 };
 export {};

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

@@ -1,3 +1,4 @@
+import queryString from 'query-string';
 export var PostMessageTypes;
 (function (PostMessageTypes) {
     PostMessageTypes["ReceiveUser"] = "receive-user";
@@ -14,10 +15,11 @@ export const embeddedAuthProvider = (getUserData, { queryKey = 'auth', window })
         }
     };
     window.addEventListener('message', messageHandler);
-    const getAuthorizedEmbedUrl = (urlString) => {
+    const getAuthorizedEmbedUrl = (urlString, extraParams) => {
         const url = new URL(urlString);
         trustedEmbeds.add(url.origin);
-        url.searchParams.set(queryKey, embeddedQueryValue);
+        const params = queryString.parse(url.search);
+        url.search = queryString.stringify({ ...params, ...extraParams, [queryKey]: embeddedQueryValue });
         return url.href;
     };
     return {

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,11 +83,12 @@ 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;
+        ensureSync?: boolean | undefined;
         user?: string | undefined;
         anyUser?: boolean | undefined;
     }) => Promise<{
@@ -98,11 +99,12 @@ 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;
+        ensureSync?: boolean | undefined;
         user?: string | undefined;
         anyUser?: boolean | undefined;
     }) => Promise<XapiStatement[]>;

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,25 @@ ${await response.text()}`);
                 Authorization: await lrsAuthorization(),
                 'X-Experience-API-Version': '1.0.0',
             },
-        }));
-        const getAllXapiStatements = async (...args) => {
+        });
+        const getXapiStatements = async (params) => {
+            if (params.ensureSync) {
+                const date = new Date();
+                return retryWithDelay(async () => {
+                    const responsePromise = fetchXapiStatements(params);
+                    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(params));
+            }
+        };
+        const getAllXapiStatements = async (params) => {
             const loadRemaining = async (result) => {
                 if (!result.more) {
                     return result.statements;
@@ -84,7 +101,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,