@openstax/ts-utils 1.5.5 → 1.5.7

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/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/xapiUtils.js

@@ -33,7 +33,9 @@ export const getScoreGrade = (score, completed, userId, maxScore) => {
     return {
         userId,
         activityProgress: completed ? 'Completed' : 'Started',
-        gradingProgress: completed ? 'FullyGraded' : 'NotReady',
+        // canvas assumes that anything that isn't 'FullyGraded' requires manual grading and displays a "needs grading" icon.
+        // if you warp your mind you can consider the portion of the assignment which is completed to be fully graded.
+        gradingProgress: 'FullyGraded',
         scoreMaximum,
         scoreGiven: roundToPrecision(scoreGiven, -2),
     };