@openstax/ts-utils 1.5.4 → 1.5.6

package/dist/esm/assertions.d.ts

@@ -1,4 +1,5 @@
-declare type AssertionFailed = string | Error | (() => never) | undefined;
+export declare type AssertionFailed = string | Error | (() => never) | undefined;
+export declare const doThrow: (failed: AssertionFailed) => never;
 /**
  * Asserts that the given value is true.
  *
@@ -82,4 +83,3 @@ export declare const assertInstanceOf: <T>(thing: any, constructable: Function &
  * @see assertInstanceOf
  */
 export declare const assertErrorInstanceOf: <T extends Error>(thing: unknown, constructable: Function & (new (...args: any[]) => T)) => T;
-export {};

package/dist/esm/assertions.js

@@ -11,7 +11,7 @@
  * stack trace more useful, and allows you to use specific error types
  * that might be handled differently.
  */
-const doThrow = (failed) => {
+export const doThrow = (failed) => {
     if (typeof failed === 'string') {
         throw new Error(failed);
     }

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

@@ -18,6 +18,11 @@ export interface ApiUser extends TokenUser {
         is_verified: boolean;
         is_guessed_preferred: boolean;
     }>;
+    applications: Array<{
+        id: number;
+        name: string;
+        roles: string[];
+    }>;
     external_ids: string[];
     is_not_gdpr_location: boolean;
     signed_contract_names: string[];

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

@@ -0,0 +1,13 @@
+import { AuthProvider } from '..';
+import { AssertionFailed } from '../../../assertions';
+import { ConfigProviderForConfig } from '../../../config';
+declare type Config = {
+    application: string;
+};
+export declare const createUserRoleValidator: (auth: AuthProvider, config: ConfigProviderForConfig<Config>) => {
+    getUserRoles: () => Promise<string[]>;
+    userHasRole: (role: string[]) => Promise<boolean>;
+    assertUserRole: (role: string[], fail?: AssertionFailed) => Promise<void>;
+};
+export declare type UserRoleValidator = ReturnType<typeof createUserRoleValidator>;
+export {};

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

@@ -0,0 +1,33 @@
+import { doThrow } from '../../../assertions';
+import { resolveConfigValue } from '../../../config/resolveConfigValue';
+import { UnauthorizedError } from '../../../errors';
+import { once } from '../../../misc/helpers';
+export const createUserRoleValidator = (auth, config) => {
+    const application = once(() => resolveConfigValue(config.application));
+    const getUserRoles = async () => {
+        var _a;
+        const user = await auth.getUser();
+        const appName = await application();
+        if (!user || !('applications' in user)) {
+            return [];
+        }
+        return ((_a = user.applications.find(a => a.name === appName)) === null || _a === void 0 ? void 0 : _a.roles) || [];
+    };
+    const userHasRole = async (role) => {
+        const roles = await getUserRoles();
+        if (!roles.some(r => role.includes(r))) {
+            return false;
+        }
+        return true;
+    };
+    const assertUserRole = async (role, fail = new UnauthorizedError()) => {
+        if (!await userHasRole(role)) {
+            return doThrow(fail);
+        }
+    };
+    return {
+        getUserRoles,
+        userHasRole,
+        assertUserRole
+    };
+};

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

@@ -24,8 +24,10 @@ export declare const resolveAttemptInfo: (statements: XapiStatement[], options?:
     currentPreference?: "latest" | "oldest" | undefined;
 } | undefined) => ActivityState;
 export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGateway, activityIRI: string, options?: {
+    anyUser?: boolean | undefined;
     attempt?: string | undefined;
     ensureSync?: boolean | undefined;
+    user?: string | undefined;
 } | undefined) => Promise<XapiStatement[]>;
 export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
     currentAttempt?: string | undefined;

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

@@ -88,7 +88,7 @@ ${await response.text()}`);
                         throw new Error(`xAPI consistent through ${consistentThrough}; not in sync with current date ${date}.`);
                     }
                     return formatGetXapiStatementsResponse(responsePromise);
-                });
+                }, { retries: 4 });
             }
             else {
                 return formatGetXapiStatementsResponse(fetchXapiStatements(fetchParams));