@openstax/ts-utils 1.3.2 → 1.5.0

package/dist/cjs/config/envConfig.d.ts

@@ -21,4 +21,4 @@ export declare const ENV_BUILD_CONFIGS: string[];
  *
  * @example const config = { configValue: envConfig('environment_variable_name') };
  */
-export declare const envConfig: (name: string, type?: 'build' | 'runtime', defaultValue?: string | undefined) => ConfigValueProvider<string>;
+export declare const envConfig: (name: string, type?: 'build' | 'runtime', defaultValue?: ConfigValueProvider<string> | undefined) => ConfigValueProvider<string>;

package/dist/cjs/services/accountsGateway/index.d.ts

@@ -0,0 +1,77 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { JsonCompatibleStruct } from '../../routing';
+import { ApiUser } from '../authProvider';
+import { Logger } from '../logger';
+export declare type Config = {
+    accountsBase: string;
+    accountsAuthToken: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export declare type FindUserPayload = ({
+    external_id: string;
+} | {
+    uuid: string;
+}) & {
+    sso?: string;
+};
+export declare type FindOrCreateUserPayload = {
+    external_id: string;
+    email?: string;
+    already_verified?: boolean;
+    first_name?: string;
+    last_name?: string;
+    full_name?: string;
+    salesforce_contact_id?: string;
+    faculty_status?: string;
+    role?: string;
+    school_type?: string;
+    is_test?: boolean;
+    sso?: string;
+};
+export declare type FindOrCreateUserResponse = {
+    id: number;
+    uuid: string;
+    external_ids: string[];
+    is_test: boolean;
+    sso: string;
+};
+export declare type FindUserResponse = (FindOrCreateUserResponse & {
+    external_ids: string[];
+}) | undefined;
+export declare type LinkUserPayload = {
+    userId: number;
+    externalId: string;
+};
+export declare type LinkUserResponse = {
+    user_id: number;
+    external_id: string;
+};
+export declare type SearchUsersPayload = {
+    q: string;
+    order_by?: string;
+};
+export declare type SearchUsersResponse = {
+    items: Array<ApiUser & {
+        external_ids: string[];
+    } & JsonCompatibleStruct>;
+    total_count: number;
+};
+export declare const accountsGateway: <C extends string = "accounts">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    accountsBase: import("../../config").ConfigValueProvider<string>;
+    accountsAuthToken: import("../../config").ConfigValueProvider<string>;
+}; }) => {
+    findOrCreateUser: (body: FindOrCreateUserPayload) => Promise<FindOrCreateUserResponse>;
+    findUser: (body: FindUserPayload) => Promise<FindUserResponse>;
+    getUser: (token: string) => Promise<ApiUser & JsonCompatibleStruct>;
+    linkUser: (body: LinkUserPayload) => Promise<LinkUserResponse>;
+    mapUserUuids: <T>(userUuidsMap: {
+        [uuid: string]: T;
+    }, logger: Logger, platformId?: string | undefined) => Promise<[string, T][]>;
+    searchUsers: (payload: SearchUsersPayload) => Promise<SearchUsersResponse>;
+};
+export declare type AccountsGateway = ReturnType<ReturnType<typeof accountsGateway>>;
+export {};

package/dist/cjs/services/accountsGateway/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountsGateway = void 0;
+const lodash_1 = require("lodash");
+const query_string_1 = __importDefault(require("query-string"));
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const routing_1 = require("../../routing");
+const logger_1 = require("../logger");
+class ApiError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+const accountsGateway = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'accounts')];
+    const accountsBase = (0, config_1.resolveConfigValue)(config.accountsBase);
+    const accountsAuthToken = (0, config_1.resolveConfigValue)(config.accountsAuthToken);
+    const request = async (method, path, options, statuses = [200, 201]) => {
+        const host = (await accountsBase).replace(/\/+$/, '');
+        const url = `${host}/api/${path}`;
+        const config = {
+            headers: {
+                Authorization: `Bearer ${options.token || await accountsAuthToken}`,
+            },
+            method,
+        };
+        if (options.body) {
+            config.body = JSON.stringify(options.body);
+        }
+        const response = await initializer.fetch(url, config);
+        if (!statuses.includes(response.status)) {
+            throw new ApiError(`Received unexpected status code ${response.status} for Accounts API call: ${method} ${url}`, response.status);
+        }
+        return response.json();
+    };
+    const findOrCreateUser = async (body) => request(routing_1.METHOD.POST, 'user/find-or-create', { body });
+    const findUser = async (body) => {
+        try {
+            return await request(routing_1.METHOD.POST, 'user/find', { body });
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 404) {
+                return undefined;
+            }
+            else {
+                throw error;
+            }
+        }
+    };
+    const getUser = async (token) => request(routing_1.METHOD.GET, 'user', { token });
+    const linkUser = async (body) => request(routing_1.METHOD.POST, 'user/external-ids', {
+        body: {
+            external_id: body.externalId,
+            user_id: body.userId,
+        }
+    });
+    const searchUsers = async (payload) => request(routing_1.METHOD.GET, `users?${query_string_1.default.stringify(payload)}`, {});
+    const getPlatformUserId = (externalIds, platformId) => {
+        for (const externalId of externalIds) {
+            const [userPlatformId, userId] = externalId.split('/', 2);
+            if (userPlatformId === platformId) {
+                return userId;
+            }
+        }
+    };
+    /*
+     * If a platformId is given, returns an array where
+     * the first element is the user id from the platform
+     * and the second is the value from the map
+     * Otherwise, returns an array where
+     * the first element is the user's full_name
+     * and the second is the value from the map
+     */
+    const mapUserUuids = async (userUuidsMap, logger, platformId) => {
+        const results = [];
+        // Accounts will not return any results if this search returns more than 10 users
+        const chunkedUuids = (0, lodash_1.chunk)(Object.keys(userUuidsMap), 10);
+        await Promise.all(chunkedUuids.map(async (uuids) => {
+            const { items } = await searchUsers({ q: uuids.map((uuid) => `uuid:${uuid}`).join(' ') });
+            const accountsUuids = items.map((user) => user.uuid);
+            if (!(0, lodash_1.isEqual)(accountsUuids.sort(), uuids.sort())) {
+                logger.logEvent(logger_1.Level.Warn, {
+                    message: 'Unexpected Accounts user search results',
+                    uuids,
+                    accountsUuids,
+                });
+            }
+            items.forEach((user) => {
+                const userId = platformId ? getPlatformUserId(user.external_ids, platformId) : user.full_name;
+                if (!userId) {
+                    const missing = platformId ? 'external_id matching the given platformId' : 'full_name';
+                    logger.logEvent(logger_1.Level.Warn, {
+                        message: `Accounts user has no ${missing}`,
+                        accountsUuid: user.uuid,
+                        platformId,
+                    });
+                }
+                results.push([userId || 'N/A', userUuidsMap[user.uuid]]);
+            });
+        }));
+        return results;
+    };
+    return { findOrCreateUser, findUser, getUser, linkUser, mapUserUuids, searchUsers };
+};
+exports.accountsGateway = accountsGateway;

package/dist/cjs/services/apiGateway/index.d.ts

@@ -1,3 +1,4 @@
+import { Headers } from 'node-fetch';
 import { ConfigProviderForConfig } from '../../config';
 import { ConfigForFetch, GenericFetch, Response } from '../../fetch';
 import { AnyRoute, ApiResponse, OutputForRoute, ParamsForRoute, PayloadForRoute, QueryParams } from '../../routing';
@@ -24,11 +25,13 @@ interface AcceptStatus<Ro> {
     <S extends number[]>(...args: S): ApiClientResponse<any>;
 }
 declare type UnsafeApiClientResponse<Ro> = {
+    headers: Headers;
     load: () => Promise<any>;
     status: number;
     acceptStatus: AcceptStatus<Ro>;
 };
 declare type ApiClientResponse<Ro> = Ro extends any ? {
+    headers: Headers;
     status: TResponseStatus<Ro>;
     load: () => Promise<TResponsePayload<Ro>>;
 } : never;

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

@@ -2,7 +2,7 @@ import { ConfigProviderForConfig } from '../../config';
 import { FetchConfig, GenericFetch } from '../../fetch';
 import { User } from '.';
 declare type Config = {
-    accountsUrl: string;
+    accountsBase: string;
 };
 interface Initializer<C> {
     configSpace?: C;
@@ -28,7 +28,7 @@ export interface Window {
     removeEventListener: (event: 'message', callback: EventHandler) => void;
 }
 export declare const browserAuthProvider: <C extends string = "auth">({ window, configSpace }: Initializer<C>) => (configProvider: { [key in C]: {
-    accountsUrl: import("../../config").ConfigValueProvider<string>;
+    accountsBase: import("../../config").ConfigValueProvider<string>;
 }; }) => {
     /**
      * adds auth parameters to the url. this is only safe to use when using javascript to navigate

package/dist/cjs/services/authProvider/browser.js

@@ -7,7 +7,7 @@ const guards_1 = require("../../guards");
 const embeddedAuthProvider_1 = require("./utils/embeddedAuthProvider");
 const browserAuthProvider = ({ window, configSpace }) => (configProvider) => {
     const config = configProvider[(0, guards_1.ifDefined)(configSpace, 'auth')];
-    const accountsUrl = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.accountsUrl));
+    const accountsBase = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.accountsBase));
     const queryString = window.location.search;
     const queryKey = 'auth';
     const authQuery = new URLSearchParams(queryString).get(queryKey);
@@ -71,7 +71,7 @@ const browserAuthProvider = ({ window, configSpace }) => (configProvider) => {
      * requests user identity from accounts api using given token or cookie
      */
     const getFetchUser = async () => {
-        const response = await window.fetch((await accountsUrl()).replace(/\/+$/, '') + '/accounts/api/user', getAuthorizedFetchConfigFromData(userData));
+        const response = await window.fetch((await accountsBase()).replace(/\/+$/, '') + '/api/user', getAuthorizedFetchConfigFromData(userData));
         if (response.status === 200) {
             return { ...userData, user: await response.json() };
         }

package/dist/cjs/services/authProvider/subrequest.d.ts

@@ -3,7 +3,7 @@ import { GenericFetch } from '../../fetch';
 import { CookieAuthProvider } from '.';
 declare type Config = {
     cookieName: string;
-    accountsUrl: string;
+    accountsBase: string;
 };
 interface Initializer<C> {
     configSpace?: C;
@@ -11,6 +11,6 @@ interface Initializer<C> {
 }
 export declare const subrequestAuthProvider: <C extends string = "subrequest">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
     cookieName: import("../../config").ConfigValueProvider<string>;
-    accountsUrl: import("../../config").ConfigValueProvider<string>;
+    accountsBase: import("../../config").ConfigValueProvider<string>;
 }; }) => CookieAuthProvider;
 export {};

package/dist/cjs/services/authProvider/subrequest.js

@@ -8,7 +8,7 @@ const _1 = require(".");
 const subrequestAuthProvider = (initializer) => (configProvider) => {
     const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'subrequest')];
     const cookieName = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.cookieName));
-    const accountsUrl = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.accountsUrl));
+    const accountsBase = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.accountsBase));
     return ({ request, profile }) => {
         let user;
         const getAuthorizedFetchConfig = profile.track('getAuthorizedFetchConfig', () => async () => {
@@ -23,7 +23,7 @@ const subrequestAuthProvider = (initializer) => (configProvider) => {
             if (!token) {
                 return undefined;
             }
-            return p.trackFetch(initializer.fetch)(await accountsUrl(), { headers })
+            return p.trackFetch(initializer.fetch)((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
                 .then(response => response.json());
         });
         return {

package/dist/cjs/services/launchParams/index.d.ts

@@ -0,0 +1,2 @@
+export { createLaunchSigner } from './signer';
+export { createLaunchVerifier } from './verifier';

package/dist/cjs/services/launchParams/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchVerifier = exports.createLaunchSigner = void 0;
+var signer_1 = require("./signer");
+Object.defineProperty(exports, "createLaunchSigner", { enumerable: true, get: function () { return signer_1.createLaunchSigner; } });
+var verifier_1 = require("./verifier");
+Object.defineProperty(exports, "createLaunchVerifier", { enumerable: true, get: function () { return verifier_1.createLaunchVerifier; } });

package/dist/cjs/services/launchParams/signer.d.ts

@@ -0,0 +1,27 @@
+import { JWK } from 'node-jose';
+import { ConfigProviderForConfig } from '../../config';
+declare type Config = {
+    alg: string;
+    expiresIn: string;
+    iss: string;
+    privateKey: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+}
+/**
+ * Creates a class that can sign launch params
+ */
+export declare const createLaunchSigner: <C extends string = "launch">({ configSpace }: Initializer<C>) => (configProvider: { [key in C]: {
+    alg: import("../../config").ConfigValueProvider<string>;
+    expiresIn: import("../../config").ConfigValueProvider<string>;
+    iss: import("../../config").ConfigValueProvider<string>;
+    privateKey: import("../../config").ConfigValueProvider<string>;
+}; }) => {
+    jwks: () => Promise<{
+        keys: JWK.RawKey[];
+    }>;
+    sign: (subject: string) => Promise<string>;
+};
+export declare type LaunchSigner = ReturnType<ReturnType<typeof createLaunchSigner>>;
+export {};

package/dist/cjs/services/launchParams/signer.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchSigner = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const node_jose_1 = require("node-jose");
+const __1 = require("../..");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const SUPPORTED_ALGORITHMS = [
+    'RS256', 'RS384', 'RS512', 'ES256', 'ES384', 'ES512', 'HS256', 'HS384', 'HS512', 'PS256', 'PS384', 'PS512'
+];
+const assertAlg = (alg) => {
+    if ((SUPPORTED_ALGORITHMS).includes(alg)) {
+        return alg;
+    }
+    throw new Error(`"${alg}" is not a valid algorithm`);
+};
+/**
+ * Creates a class that can sign launch params
+ */
+const createLaunchSigner = ({ configSpace }) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(configSpace, 'launch')];
+    const getAlg = (0, __1.once)(async () => assertAlg(await (0, config_1.resolveConfigValue)(config.alg)));
+    const getExpiresIn = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.expiresIn));
+    const getIss = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.iss));
+    const getPrivateKey = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.privateKey));
+    const getKeyStore = (0, __1.once)(async () => {
+        const keystore = node_jose_1.JWK.createKeyStore();
+        await keystore.add(await getPrivateKey(), 'pem');
+        return keystore;
+    });
+    const jwks = async () => (await getKeyStore()).toJSON(false);
+    const sign = async (subject) => {
+        const alg = await getAlg();
+        const expiresIn = await getExpiresIn();
+        const iss = await getIss();
+        const header = { alg, iss };
+        return jsonwebtoken_1.default.sign({}, await getPrivateKey(), { algorithm: alg, expiresIn, header, issuer: iss, subject });
+    };
+    return { jwks, sign };
+};
+exports.createLaunchSigner = createLaunchSigner;

package/dist/cjs/services/launchParams/verifier.d.ts

@@ -0,0 +1,21 @@
+import type { JWK } from 'node-jose';
+import { ConfigProviderForConfig } from '../../config';
+declare type Config = {
+    trustedDomain: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetcher?: (uri: string) => Promise<{
+        keys: JWK.RawKey[];
+    }>;
+}
+/**
+ * Creates a class that can verify launch params
+ */
+export declare const createLaunchVerifier: <C extends string = "launch">({ configSpace, fetcher }: Initializer<C>) => (configProvider: { [key in C]: {
+    trustedDomain: import("../../config").ConfigValueProvider<string>;
+}; }) => {
+    verify: (token: string) => Promise<string>;
+};
+export declare type LaunchVerifier = ReturnType<ReturnType<typeof createLaunchVerifier>>;
+export {};

package/dist/cjs/services/launchParams/verifier.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchVerifier = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const jwks_rsa_1 = require("jwks-rsa");
+const __1 = require("../..");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+/**
+ * Creates a class that can verify launch params
+ */
+const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(configSpace, 'launch')];
+    const getJwksClient = (0, __1.memoize)((jwksUri) => new jwks_rsa_1.JwksClient({ fetcher, jwksUri }));
+    const getJwksKey = (0, __1.memoize)(async (jwksUri, kid) => {
+        const client = getJwksClient(jwksUri);
+        const key = await client.getSigningKey(kid);
+        return key.getPublicKey();
+    });
+    const getKey = async (header, callback) => {
+        // The JWT spec allows iss in the header as a copy of the iss claim, but we require it
+        if (!header.iss) {
+            return callback(new Error('JWT header missing iss claim'));
+        }
+        const { iss, kid } = header;
+        try {
+            const jwksUrl = new URL('/.well-known/jwks.json', iss);
+            const launchDomain = jwksUrl.hostname;
+            const trustedDomain = await (0, config_1.resolveConfigValue)(config.trustedDomain);
+            if (launchDomain !== trustedDomain && !launchDomain.endsWith(`.${trustedDomain}`)) {
+                return callback(new Error(`Untrusted launch domain: "${launchDomain}"`));
+            }
+            callback(null, await getJwksKey(jwksUrl.toString(), kid));
+        }
+        catch (error) {
+            callback(error);
+        }
+    };
+    const verify = (token) => new Promise((resolve, reject) => jsonwebtoken_1.default.verify(token, getKey, {}, (err, payload) => {
+        if (err) {
+            reject(err);
+        }
+        else if (typeof payload !== 'object') {
+            reject(new Error('received JWT token with unexpected non-JSON payload'));
+        }
+        else if (!payload.sub) {
+            reject(new Error('JWT payload missing sub claim'));
+        }
+        else {
+            resolve(payload.sub);
+        }
+    }));
+    return { verify };
+};
+exports.createLaunchVerifier = createLaunchVerifier;

package/dist/cjs/services/lrsGateway/xapiUtils.d.ts

@@ -0,0 +1,32 @@
+import { AccountsGateway } from '../accountsGateway';
+import { AuthProvider } from '../authProvider';
+import { Logger } from '../logger';
+import { LrsGateway } from '.';
+export interface Grade {
+    scoreGiven: number;
+    scoreMaximum: number;
+    comment?: string;
+    activityProgress: 'Initialized' | 'Started' | 'inProgress' | 'Submitted' | 'Completed';
+    gradingProgress: 'FullyGraded' | 'Pending' | 'PendingManual' | 'Failed' | 'NotReady';
+    userId: string;
+}
+export declare const getRegistrationAttemptInfo: (lrs: LrsGateway, registration: string, options?: {
+    anyUser?: boolean | undefined;
+} | undefined) => Promise<{
+    [key: string]: import("./attempt-utils").ActivityState;
+}>;
+export declare const getCurrentGrade: (services: {
+    lrs: LrsGateway;
+    ltiAuthProvider: AuthProvider;
+}, registration: string, options?: {
+    scoreMaximum?: number | undefined;
+    userId?: string | undefined;
+} | undefined) => Promise<Grade | null>;
+export declare const getAllGradesForAssignment: (services: {
+    accountsGateway: AccountsGateway;
+    lrs: LrsGateway;
+    logger: Logger;
+}, registration: string, options?: {
+    platformId?: string | undefined;
+    scoreMaximum?: number | undefined;
+} | undefined) => Promise<Grade[]>;

package/dist/cjs/services/lrsGateway/xapiUtils.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllGradesForAssignment = exports.getCurrentGrade = exports.getRegistrationAttemptInfo = void 0;
+const __1 = require("../..");
+const attempt_utils_1 = require("./attempt-utils");
+const getRegistrationAttemptInfo = async (lrs, registration, options) => {
+    const allStatements = await lrs.getAllXapiStatements({ ...options, registration, ensureSync: true });
+    // Partition statements for each user
+    const statementsPerUser = {};
+    allStatements.forEach((statement) => {
+        var _a;
+        // If we ever support accounts from different statement.actor.account.homePage, this method may need changes
+        // (unless we can guarantee the statement.actor.account.name are unique)
+        statementsPerUser[_a = statement.actor.account.name] || (statementsPerUser[_a] = []);
+        statementsPerUser[statement.actor.account.name].push(statement);
+    });
+    const result = {};
+    for (const [userUuid, userStatements] of Object.entries(statementsPerUser)) {
+        result[userUuid] = (0, attempt_utils_1.resolveAttemptInfo)(userStatements);
+    }
+    return result;
+};
+exports.getRegistrationAttemptInfo = getRegistrationAttemptInfo;
+// generates a payload that can be sent to the LMS, documentation here:
+// lti: http://www.imsglobal.org/spec/lti-ags/v2p0#score-publish-service
+// ltijs: https://cvmcosta.me/ltijs/#/grading
+const getInfoGrade = (info, userId, maxScore) => {
+    var _a;
+    const completed = info.currentAttemptCompleted;
+    const { raw, scaled, max } = ((_a = completed === null || completed === void 0 ? void 0 : completed.result) === null || _a === void 0 ? void 0 : _a.score) || {};
+    const scoreMaximum = maxScore !== null && maxScore !== void 0 ? maxScore : 100;
+    const scoreGiven = raw && max
+        ? scoreMaximum / max * raw
+        : scaled
+            ? scaled * scoreMaximum
+            : 0;
+    return {
+        userId,
+        activityProgress: completed ? 'Completed' : 'Started',
+        gradingProgress: completed ? 'FullyGraded' : 'NotReady',
+        scoreMaximum,
+        scoreGiven: (0, __1.roundToPrecision)(scoreGiven, -2),
+    };
+};
+const getCurrentGrade = async (services, registration, options) => {
+    var _a;
+    const user = await services.ltiAuthProvider.getUser();
+    if (!user) {
+        return null;
+    }
+    const infoPerUser = await (0, exports.getRegistrationAttemptInfo)(services.lrs, registration);
+    const userInfo = infoPerUser[user.uuid];
+    return getInfoGrade(userInfo !== null && userInfo !== void 0 ? userInfo : (0, attempt_utils_1.resolveAttemptInfo)([]), (_a = options === null || options === void 0 ? void 0 : options.userId) !== null && _a !== void 0 ? _a : user.uuid, options === null || options === void 0 ? void 0 : options.scoreMaximum);
+};
+exports.getCurrentGrade = getCurrentGrade;
+const getAllGradesForAssignment = async (services, registration, options) => {
+    const infoPerUserUuid = await (0, exports.getRegistrationAttemptInfo)(services.lrs, registration, { anyUser: true });
+    const mappedResults = await services.accountsGateway.mapUserUuids(infoPerUserUuid, services.logger, options === null || options === void 0 ? void 0 : options.platformId);
+    return mappedResults.map(([userId, userInfo]) => getInfoGrade(userInfo, userId, options === null || options === void 0 ? void 0 : options.scoreMaximum));
+};
+exports.getAllGradesForAssignment = getAllGradesForAssignment;

package/dist/cjs/services/searchProvider/memorySearchTheBadWay.js

@@ -36,8 +36,11 @@ const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                             }
                             : (x) => x;
                         const hasMatch = (0, __1.coerceArray)(field.value).map(coerceValue).some(v => docValues.includes(v));
-                        return !((mustMatch === MatchType.Must && !hasMatch) || (mustMatch === MatchType.MustNot && hasMatch));
+                        if ((mustMatch === MatchType.Must && !hasMatch) || (mustMatch === MatchType.MustNot && hasMatch)) {
+                            return false;
+                        }
                     }
+                    return true;
                 };
                 if (options.query !== undefined) {
                     for (const field of options.fields) {