@openstax/ts-utils 1.2.3 → 1.2.5

package/dist/cjs/middleware/lambdaCorsResponseMiddleware.js

@@ -6,7 +6,7 @@ const routing_1 = require("../routing");
 const createLambdaCorsResponseMiddleware = (config) => (responsePromise, { request }) => {
     const cors = async () => {
         const allowedHost = await (0, resolveConfigValue_1.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/cjs/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/cjs/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/cjs/services/authProvider/utils/embeddedAuthProvider.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.embeddedAuthProvider = exports.PostMessageTypes = void 0;
+const query_string_1 = __importDefault(require("query-string"));
 var PostMessageTypes;
 (function (PostMessageTypes) {
     PostMessageTypes["ReceiveUser"] = "receive-user";
@@ -17,10 +21,11 @@ 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 = query_string_1.default.parse(url.search);
+        url.search = query_string_1.default.stringify({ ...params, ...extraParams, [queryKey]: embeddedQueryValue });
         return url.href;
     };
     return {

package/dist/cjs/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/cjs/services/lrsGateway/attempt-utils.js

@@ -91,35 +91,42 @@ exports.resolveActivityAttemptInfo = resolveActivityAttemptInfo;
  * 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.
  */
-const loadStatementsForActivityAndFirstChildren = (gateway, activityIRI, attempt) => {
+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,
     });
 };
 exports.loadStatementsForActivityAndFirstChildren = loadStatementsForActivityAndFirstChildren;
 /*
  * loads all statements (for this actor) that have the given parent attempt (registration)
  */
-const loadStatementsForAttempt = (gateway, attempt) => {
+const loadStatementsForAttempt = (gateway, attempt, options) => {
     return gateway.getAllXapiStatements({
-        registration: attempt
+        registration: attempt,
+        ...(options ? options : {})
     });
 };
 exports.loadStatementsForAttempt = loadStatementsForAttempt;
 /*
  * loads all statements (for this actor) that have the given activityIRI as the object.id
  */
-const loadStatementsForActivity = (gateway, activityIRI, attempt) => {
+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,
     });
 };
 exports.loadStatementsForActivity = loadStatementsForActivity;
 const loadActivityAttemptInfo = async (gateway, activityIRI, options) => {
-    return (0, exports.resolveActivityAttemptInfo)(await (0, exports.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 (0, exports.resolveActivityAttemptInfo)(await (0, exports.loadStatementsForActivity)(gateway, activityIRI, loadOptions), activityIRI, options);
 };
 exports.loadActivityAttemptInfo = loadActivityAttemptInfo;
 const createStatement = (verb, activity, attempt, parentActivityIRI) => {

package/dist/cjs/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/cjs/services/lrsGateway/index.js

@@ -88,7 +88,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({
@@ -104,8 +104,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 (0, __1.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;
@@ -113,7 +130,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,