@openstax/ts-utils 1.25.1 → 1.25.2

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

@@ -70,16 +70,26 @@ export declare type MappedUserInfo<T> = {
 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>;
-}; }) => {
+}; }) => ({ logger }: {
+    logger: Logger;
+}) => {
     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<MappedUserInfo<T>[]>;
+    }, platformId?: string | undefined) => Promise<{
+        data: T;
+        fullName: string;
+        platformUserId: string | undefined;
+        uuid: string;
+    }[]>;
     searchUsers: (payload: SearchUsersPayload) => Promise<SearchUsersResponse>;
     updateUser: (token: string, body: UpdateUserPayload) => Promise<ApiUser & JsonCompatibleStruct>;
+    getUserMap: <R>(userUuids: Set<string>, mapper: (user: ApiUser) => R) => Promise<Map<string, R>>;
+    mapUserData: <T_1, R_1>(input: T_1[], getUserUuid: (item: T_1) => string, mapper: (user: ApiUser | undefined, item: T_1) => R_1) => Promise<R_1[]>;
+    mapUsersData: <T_2, R_2>(input: T_2[], getUserUuids: (item: T_2) => string[], mapper: (users: Map<string, ApiUser | undefined>, item: T_2) => R_2) => Promise<R_2[]>;
 };
-export declare type AccountsGateway = ReturnType<ReturnType<typeof accountsGateway>>;
+export declare type AccountsGateway = ReturnType<ReturnType<ReturnType<typeof accountsGateway>>>;
 export {};

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

@@ -1,7 +1,7 @@
 import { chunk, isEqual } from 'lodash';
 import queryString from 'query-string';
 import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
+import { ifDefined, isDefined } from '../../guards';
 import { METHOD } from '../../routing';
 import { Level } from '../logger';
 class ApiError extends Error {
@@ -14,78 +14,68 @@ export const accountsGateway = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'accounts')];
     const accountsBase = resolveConfigValue(config.accountsBase);
     const accountsAuthToken = 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,
+    return ({ logger }) => {
+        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();
         };
-        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(METHOD.POST, 'user/find-or-create', { body });
-    const findUser = async (body) => {
-        try {
-            return await request(METHOD.POST, 'user/find', { body });
-        }
-        catch (error) {
-            if (error instanceof ApiError && error.status === 404) {
-                return undefined;
+        const findOrCreateUser = async (body) => request(METHOD.POST, 'user/find-or-create', { body });
+        const findUser = async (body) => {
+            try {
+                return await request(METHOD.POST, 'user/find', { body });
             }
-            else {
-                throw error;
+            catch (error) {
+                if (error instanceof ApiError && error.status === 404) {
+                    return undefined;
+                }
+                else {
+                    throw error;
+                }
             }
-        }
-    };
-    const getUser = async (token) => request(METHOD.GET, 'user', { token });
-    const linkUser = async (body) => request(METHOD.POST, 'user/external-ids', {
-        body: {
-            external_id: body.externalId,
-            user_id: body.userId,
-        }
-    });
-    const searchUsers = async (payload) => request(METHOD.GET, `users?${queryString.stringify(payload)}`, {});
-    const updateUser = async (token, body) => request(METHOD.PUT, 'user', { body, token });
-    const getPlatformUserId = (externalIds, platformId) => {
-        for (const externalId of externalIds) {
-            const [userPlatformId, userId] = externalId.split('/', 2);
-            if (userPlatformId === platformId) {
-                return userId;
+        };
+        const getUser = async (token) => request(METHOD.GET, 'user', { token });
+        const linkUser = async (body) => request(METHOD.POST, 'user/external-ids', {
+            body: {
+                external_id: body.externalId,
+                user_id: body.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 = 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 (!isEqual(accountsUuids.sort(), uuids.sort())) {
-                logger.logEvent(Level.Warn, {
-                    message: 'Unexpected Accounts user search results',
-                    uuids,
-                    accountsUuids,
-                });
+        });
+        const searchUsers = async (payload) => request(METHOD.GET, `users?${queryString.stringify(payload)}`, {});
+        const updateUser = async (token, body) => request(METHOD.PUT, 'user', { body, token });
+        const getPlatformUserId = (externalIds, platformId) => {
+            for (const externalId of externalIds) {
+                const [userPlatformId, userId] = externalId.split('/', 2);
+                if (userPlatformId === platformId) {
+                    return userId;
+                }
             }
-            items.forEach((user) => {
+        };
+        /*
+         * 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, platformId) => {
+            const results = await mapUserData(Object.entries(userUuidsMap), ([id]) => id, (user, [, data]) => {
+                if (!user)
+                    return undefined;
                 const platformUserId = platformId ? getPlatformUserId(user.external_ids, platformId) : undefined;
                 if (platformId && !platformUserId) {
                     logger.logEvent(Level.Warn, {
@@ -100,12 +90,41 @@ export const accountsGateway = (initializer) => (configProvider) => {
                         accountsUuid: user.uuid,
                     });
                 }
-                results.push({
-                    data: userUuidsMap[user.uuid], fullName: user.full_name, platformUserId, uuid: user.uuid,
+                return { data, fullName: user.full_name, platformUserId, uuid: user.uuid };
+            });
+            return results.filter(isDefined);
+        };
+        const getUserMap = async (userUuids, mapper) => {
+            if (userUuids.size === 0)
+                return new Map();
+            const chunked = chunk([...userUuids], 10);
+            const results = await Promise.all(chunked.map(async (inputChunk) => {
+                const { items } = await searchUsers({ q: inputChunk.map(userUuid => `uuid:${userUuid}`).join(' ')
                 });
+                const accountsUuids = items.map((user) => user.uuid);
+                if (!isEqual(accountsUuids.sort(), inputChunk.sort())) {
+                    logger.logEvent(Level.Warn, {
+                        message: 'Unexpected Accounts user search results',
+                        uuids: inputChunk,
+                        accountsUuids,
+                    });
+                }
+                return items;
+            }));
+            return new Map(results.flat(1).map(user => [user.uuid, mapper(user)]));
+        };
+        const mapUserData = async (input, getUserUuid, mapper) => {
+            const userMap = await getUserMap(new Set(input.flatMap(getUserUuid)), user => user);
+            return input.map(item => mapper(userMap.get(getUserUuid(item)), item));
+        };
+        const mapUsersData = async (input, getUserUuids, mapper) => {
+            const userMap = await getUserMap(new Set(input.flatMap(getUserUuids)), user => user);
+            return input.map(item => {
+                const userUuids = getUserUuids(item);
+                const itemUserMap = new Map(userUuids.map(uuid => [uuid, userMap.get(uuid)]));
+                return mapper(itemUserMap, item);
             });
-        }));
-        return results;
+        };
+        return { findOrCreateUser, findUser, getUser, linkUser, mapUserUuids, searchUsers, updateUser, getUserMap, mapUserData, mapUsersData };
     };
-    return { findOrCreateUser, findUser, getUser, linkUser, mapUserUuids, searchUsers, updateUser };
 };

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

@@ -1,5 +1,6 @@
 import { JWK } from 'node-jose';
 import { ConfigProviderForConfig } from '../../config';
+import type { JsonCompatibleValue } from '../../routing';
 declare type Config = {
     alg: string;
     expiresIn: string;
@@ -21,7 +22,7 @@ export declare const createLaunchSigner: <C extends string = "launch">({ configS
     jwks: () => Promise<{
         keys: JWK.RawKey[];
     }>;
-    sign: (subject: string, maxExp?: number | null | undefined) => Promise<string>;
+    sign: (data: Record<string, JsonCompatibleValue>, subject: string, maxExp?: number | null | undefined) => Promise<string>;
 };
 export declare type LaunchSigner = ReturnType<ReturnType<typeof createLaunchSigner>>;
 export {};

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

@@ -39,13 +39,13 @@ export const createLaunchSigner = ({ configSpace }) => (configProvider) => {
         const maxExpSeconds = maxExp - Math.floor(Date.now() / 1000);
         return Math.min(expiresInSeconds, maxExpSeconds);
     };
-    const sign = async (subject, maxExp) => {
+    const sign = async (data, subject, maxExp) => {
         const alg = await getAlg();
         // expiresIn can be a number of seconds or a string like '1h' or '1d'
         const expiresIn = await getExpiresInWithMax(maxExp);
         const iss = await getIss();
         const header = { alg, iss };
-        return jwt.sign({}, await getPrivateKey(), { algorithm: alg, expiresIn, header, issuer: iss, subject });
+        return jwt.sign(data, await getPrivateKey(), { algorithm: alg, expiresIn, header, issuer: iss, subject });
     };
     return { jwks, sign };
 };

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

@@ -1,6 +1,5 @@
 import { AccountsGateway, MappedUserInfo } from '../accountsGateway';
 import { AuthProvider } from '../authProvider';
-import { Logger } from '../logger';
 import { ActivityState } from './attempt-utils';
 import { LrsGateway } from '.';
 export interface Grade {
@@ -50,7 +49,6 @@ export declare type UserActivityInfo = MappedUserInfo<ActivityState>;
 export declare const getAssignmentGrades: (services: {
     accountsGateway: AccountsGateway;
     lrs: LrsGateway;
-    logger: Logger;
 }, assignmentIRI: string, registration: string, options?: {
     anyUser?: boolean | undefined;
     currentPreference?: "latest" | "oldest" | undefined;

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

@@ -75,7 +75,7 @@ export const getCurrentGrade = async (services, registration, options) => {
 export const getAssignmentGrades = async (services, assignmentIRI, registration, options) => {
     const { anyUser, currentPreference, incompleteAttemptsCallback, platformId, scoreMaximum, user } = options !== null && options !== void 0 ? options : {};
     const infoPerUserUuid = await getRegistrationAttemptInfo(services.lrs, registration, { activity: assignmentIRI, anyUser, currentPreference, user });
-    const mappedInfo = await services.accountsGateway.mapUserUuids(infoPerUserUuid, services.logger, platformId);
+    const mappedInfo = await services.accountsGateway.mapUserUuids(infoPerUserUuid, platformId);
     if (!incompleteAttemptsCallback) {
         return getCompletedUserInfosGradeAndProgress(mappedInfo, scoreMaximum);
     }

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

@@ -28,5 +28,9 @@ export interface SearchOptions {
     must?: Filter[];
     must_not?: Filter[];
     should?: Filter[];
+    sort?: {
+        key: string;
+        order: 'asc' | 'desc';
+    }[];
 }
 export {};

package/dist/esm/services/searchProvider/memorySearchTheBadWay.d.ts

@@ -4,6 +4,7 @@ export declare const memorySearchTheBadWay: () => <T>({ store }: {
         loadAllDocumentsTheBadWay: () => Promise<T[]>;
     };
 }) => {
+    deleteIndexIfExists: () => Promise<undefined>;
     ensureIndexCreated: () => Promise<undefined>;
     index: (_options: IndexOptions<T>) => Promise<undefined>;
     search: (options: SearchOptions) => Promise<{

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

@@ -12,6 +12,8 @@ var MatchType;
 const resolveField = (document, field) => field.key.toString().split('.').reduce((result, key) => result[key], document);
 export const memorySearchTheBadWay = () => ({ store }) => {
     return {
+        // This method is intentionally stubbed because index deletion is not applicable for in-memory storage.
+        deleteIndexIfExists: async () => undefined,
         ensureIndexCreated: async () => undefined,
         index: async (_options) => undefined,
         search: async (options) => {
@@ -77,7 +79,19 @@ export const memorySearchTheBadWay = () => ({ store }) => {
             })
                 .filter(isDefined)
                 .filter(r => !options.query || r.weight >= MIN_MATCH);
-            results.sort((a, b) => b.weight - a.weight);
+            results.sort((a, b) => {
+                for (const sort of (options.sort || [])) {
+                    const aValue = resolveField(a.document, { key: sort.key });
+                    const bValue = resolveField(b.document, { key: sort.key });
+                    if (aValue < bValue) {
+                        return sort.order === 'asc' ? -1 : 1;
+                    }
+                    if (aValue > bValue) {
+                        return sort.order === 'asc' ? 1 : -1;
+                    }
+                }
+                return b.weight - a.weight;
+            });
             const page = options.page || 1;
             const offset = (page - 1) * MAX_RESULTS;
             return {

package/dist/esm/services/searchProvider/openSearch.d.ts

@@ -17,6 +17,7 @@ export declare const openSearchService: <C extends string = "deployed">(initiali
     region: import("../../config").ConfigValueProvider<string>;
 }; }) => <T>(indexConfig: IndexConfig) => {
     ensureIndexCreated: () => Promise<void>;
+    deleteIndexIfExists: () => Promise<void>;
     index: (params: IndexOptions<T>) => Promise<void>;
     search: (options: SearchOptions) => Promise<{
         items: Exclude<T, undefined>[];

package/dist/esm/services/searchProvider/openSearch.js

@@ -17,24 +17,29 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
     }));
     return (indexConfig) => {
         const pageSize = indexConfig.pageSize || 10;
-        const createIndexIfNotExists = async (indices, params) => {
-            const { index } = params;
+        const deleteIndexIfExists = async () => {
+            const { indices } = await client();
+            const index = indexConfig.name;
             const { body } = await indices.exists({ index });
-            if (!body) {
-                await indices.create(params);
+            if (body) {
+                await indices.delete({ index });
             }
         };
         const ensureIndexCreated = async () => {
             const { indices } = await client();
-            await createIndexIfNotExists(indices, {
-                index: indexConfig.name,
-                body: {
-                    mappings: {
-                        dynamic: false,
-                        properties: indexConfig.mappings
+            const index = indexConfig.name;
+            const { body } = await indices.exists({ index });
+            if (!body) {
+                await indices.create({
+                    index,
+                    body: {
+                        mappings: {
+                            dynamic: false,
+                            properties: indexConfig.mappings
+                        }
                     }
-                }
-            });
+                });
+            }
         };
         const index = async (params) => {
             const openSearchClient = await client();
@@ -81,6 +86,11 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
                 });
                 body.query.bool.minimum_should_match = 1;
             }
+            if (options.sort && options.sort.length > 0) {
+                body.sort = options.sort.map(sort => ({
+                    [sort.key]: { order: sort.order }
+                }));
+            }
             if (options.page) {
                 body.size = pageSize;
                 body.from = (options.page - 1) * pageSize;
@@ -100,6 +110,6 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
             const totalPages = Math.ceil(totalItems / pageSize) || 1;
             return { items, pageSize, currentPage, totalItems, totalPages };
         };
-        return { ensureIndexCreated, index, search };
+        return { ensureIndexCreated, deleteIndexIfExists, index, search };
     };
 };