@openstax/ts-utils 1.33.1 → 1.34.0

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

@@ -1,99 +0,0 @@
-import partition from 'lodash/fp/partition';
-import { roundToPrecision } from '../..';
-import { resolveAttemptInfo } from './attempt-utils';
-export const getRegistrationAttemptInfo = async (lrs, registration, options) => {
-    const { currentPreference, ...xapiOptions } = options !== null && options !== void 0 ? options : {};
-    const allStatements = await lrs.getAllXapiStatements({ ...xapiOptions, registration });
-    // 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] = resolveAttemptInfo(userStatements, { currentPreference });
-    }
-    return result;
-};
-// 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
-// Note: "min" is currently completely ignored
-export const getScoreGrade = (score, options) => {
-    const { raw, scaled, max } = score;
-    const { maxScore, startedAt, submittedAt, userId } = options;
-    const scoreMaximum = maxScore !== null && maxScore !== void 0 ? maxScore : 100;
-    const scoreGiven = raw && max
-        ? scoreMaximum / max * raw
-        : scaled
-            ? scaled * scoreMaximum
-            : 0;
-    const submission = {};
-    if (startedAt) {
-        submission.startedAt = startedAt;
-    }
-    if (submittedAt) {
-        submission.submittedAt = submittedAt;
-    }
-    return {
-        userId,
-        activityProgress: submittedAt ? 'Completed' : 'Started',
-        // 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),
-        submission,
-    };
-};
-// These methods assign 0's to incomplete activities
-const getCompletedActivityStateGradeAndProgress = ({ name, scoreMaximum, state, userId }) => {
-    var _a, _b, _c, _d;
-    return ({
-        grade: getScoreGrade(((_b = (_a = state.currentAttemptCompleted) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.score) || {}, {
-            maxScore: scoreMaximum,
-            startedAt: (_c = state.currentAttempt) === null || _c === void 0 ? void 0 : _c.timestamp,
-            submittedAt: (_d = state.currentAttemptCompleted) === null || _d === void 0 ? void 0 : _d.timestamp,
-            userId,
-        }),
-        progress: {
-            scaled: state.currentAttemptCompleted ? 1 : 0,
-        },
-        name,
-    });
-};
-const getCompletedUserInfosGradeAndProgress = (infos, scoreMaximum) => infos.map(({ data, fullName, platformUserId }) => getCompletedActivityStateGradeAndProgress({
-    name: fullName, scoreMaximum, userId: platformUserId, state: data
-}));
-export const getCurrentGrade = async (services, registration, options) => {
-    var _a;
-    const user = await services.ltiAuthProvider.getUser();
-    if (!user) {
-        return null;
-    }
-    const userId = (_a = options === null || options === void 0 ? void 0 : options.userId) !== null && _a !== void 0 ? _a : user.uuid;
-    const { currentPreference, incompleteAttemptCallback, name, scoreMaximum } = options !== null && options !== void 0 ? options : {};
-    const infoPerUser = await getRegistrationAttemptInfo(services.lrs, registration, { currentPreference });
-    const userInfo = infoPerUser[user.uuid];
-    if (!userInfo) {
-        return getCompletedActivityStateGradeAndProgress({ name, scoreMaximum, state: resolveAttemptInfo([]), userId });
-    }
-    if (userInfo.currentAttemptCompleted || !incompleteAttemptCallback) {
-        return getCompletedActivityStateGradeAndProgress({ name, scoreMaximum, state: userInfo, userId });
-    }
-    return incompleteAttemptCallback(userInfo);
-};
-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, platformId);
-    if (!incompleteAttemptsCallback) {
-        return getCompletedUserInfosGradeAndProgress(mappedInfo, scoreMaximum);
-    }
-    const [incompleteInfo, completedInfo] = partition((info) => info.data.currentAttemptCompleted === undefined)(mappedInfo);
-    return getCompletedUserInfosGradeAndProgress(completedInfo, scoreMaximum).concat(await incompleteAttemptsCallback(incompleteInfo));
-};

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

@@ -1,28 +0,0 @@
-import postgres, { Sql } from 'postgres';
-import { ConfigProviderForConfig } from '../../config';
-import type { Logger } from '../logger';
-type Config = {
-    host: string;
-    readHost: string;
-    port: string;
-    database: string;
-    username: string;
-    password: string;
-};
-interface Initializer<C> {
-    configSpace?: C;
-}
-export declare const postgresConnection: <C extends string = "local">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => (services: {
-    logger: Logger;
-}) => {
-    db: () => Promise<postgres.Sql<{}>>;
-    dbRead: () => Promise<postgres.Sql<{}>>;
-    migrate: (migrations: Migration[]) => Promise<void>;
-    down: () => Promise<void[]>;
-};
-export type PostgresConnection = ReturnType<ReturnType<ReturnType<typeof postgresConnection>>>;
-export interface Migration {
-    name: string;
-    up: (db: Sql) => Promise<void>;
-}
-export {};

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

@@ -1,58 +0,0 @@
-import postgres from 'postgres';
-import { assertNotNaN } from '../../assertions';
-import { resolveConfigValue } from '../../config';
-import { ifDefined } from '../../guards';
-import { once } from '../../misc/helpers';
-export const postgresConnection = (initializer) => (configProvider) => {
-    const config = configProvider[ifDefined(initializer.configSpace, 'local')];
-    const host = once(() => resolveConfigValue(config.host));
-    const readHost = once(() => resolveConfigValue(config.readHost));
-    const connectionOptions = once(async () => ({
-        port: assertNotNaN(parseInt(await resolveConfigValue(config.port), 10), new Error('port must be a number')),
-        database: await resolveConfigValue(config.database),
-        username: await resolveConfigValue(config.username),
-        password: await resolveConfigValue(config.password),
-        transform: {
-            column: { to: postgres.fromCamel, from: postgres.toCamel },
-        },
-    }));
-    const connections = [];
-    const sql = once(async () => {
-        const options = await connectionOptions();
-        const connection = postgres({ ...options, host: await host() });
-        connections.push(connection);
-        return connection;
-    });
-    const sqlRead = once(async () => {
-        const options = await connectionOptions();
-        const connection = postgres({ ...options, host: await readHost() });
-        connections.push(connection);
-        return connection;
-    });
-    return (services) => ({
-        db: sql,
-        dbRead: sqlRead,
-        migrate: async (migrations) => {
-            await migrate(services, await sql(), migrations);
-        },
-        down: () => Promise.all(connections.map(c => c.end()))
-    });
-};
-async function migrate(services, db, migrations) {
-    await db `
-    CREATE TABLE IF NOT EXISTS migrations (
-      id SERIAL PRIMARY KEY,
-      name TEXT NOT NULL,
-      ran_at TIMESTAMP NOT NULL DEFAULT NOW()
-    )
-  `;
-    const ranMigrations = await db `SELECT name FROM migrations`;
-    for (const migration of migrations) {
-        if (ranMigrations.some(({ name }) => name === migration.name)) {
-            continue;
-        }
-        services.logger.log(`Running migration ${migration.name}`);
-        await migration.up(db);
-        await db `INSERT INTO migrations (name) VALUES (${migration.name})`;
-    }
-}

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

@@ -1,67 +0,0 @@
-export type FieldType = string | string[] | number | boolean;
-export type ESFilter = {
-    terms: Record<string, FieldType>;
-} | {
-    term: Record<string, FieldType>;
-} | {
-    exists: {
-        field: string;
-    };
-} | {
-    nested: {
-        path: string;
-        query: Filter;
-    };
-} | {
-    bool: BoolFilter;
-};
-export type Filter = {
-    key: string;
-    value: FieldType;
-} | ESFilter;
-export type BoolFilter = {
-    must?: Filter[];
-    must_not?: Filter[];
-    should?: Filter[];
-    filter?: Filter[];
-    minimum_should_match?: number;
-};
-type Field = {
-    key: string;
-    type?: 'text';
-    weight: number;
-} | {
-    key: string;
-    type: 'keyword';
-} | {
-    key: string;
-    type: 'boolean';
-};
-export interface IndexOptions<T> {
-    body: T;
-    id: string;
-}
-export type FieldMapping = {
-    type: 'keyword' | 'text' | 'boolean';
-} | {
-    type: 'date';
-    format?: string;
-} | {
-    type?: 'nested' | 'object';
-    properties: Record<string, FieldMapping>;
-};
-export type FieldMappings = Record<string, FieldMapping>;
-export interface SearchOptions {
-    page?: number;
-    query: string | undefined;
-    fields: Field[];
-    filter?: Filter[];
-    must?: Filter[];
-    must_not?: Filter[];
-    should?: Filter[];
-    sort?: {
-        key: string;
-        order: 'asc' | 'desc';
-    }[];
-}
-export {};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,20 +0,0 @@
-import { FieldMappings, IndexOptions, SearchOptions } from '.';
-export type Config<T> = {
-    mappings: FieldMappings;
-    store: {
-        loadAllDocumentsTheBadWay: () => Promise<T[]>;
-    };
-};
-export declare const memorySearchTheBadWay: () => <T>({ store, mappings }: Config<T>) => {
-    deleteIndexIfExists: () => Promise<undefined>;
-    ensureIndexCreated: () => Promise<undefined>;
-    index: (_options: IndexOptions<T>) => Promise<undefined>;
-    bulkIndex: (_items: IndexOptions<T>[]) => Promise<undefined>;
-    search: (options: SearchOptions) => Promise<{
-        items: T[];
-        pageSize: number;
-        currentPage: number;
-        totalItems: number;
-        totalPages: number;
-    }>;
-};

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

@@ -1,187 +0,0 @@
-import { coerceArray } from '../..';
-import { InvalidRequestError } from '../../errors';
-import { isDefined } from '../../guards';
-const MIN_MATCH = 0.5;
-const MAX_RESULTS = 10;
-var MatchType;
-(function (MatchType) {
-    MatchType[MatchType["Must"] = 0] = "Must";
-    MatchType[MatchType["MustNot"] = 1] = "MustNot";
-    MatchType[MatchType["Should"] = 2] = "Should";
-})(MatchType || (MatchType = {}));
-const resolveField = (context, field) => {
-    const path = field.startsWith(context.scope + '.')
-        ? field.slice(context.scope.length + 1)
-        : field;
-    return path.split('.').reduce((result, key) => {
-        if (result === undefined) {
-            throw new Error(`Key "${key}" not found in document resolving ${field}`);
-        }
-        return result[key];
-    }, context.document);
-};
-const getFieldDefinition = (context, field) => {
-    let current = context.fields;
-    const parts = field.split('.');
-    const head = parts.slice(0, -1);
-    const tail = parts[parts.length - 1];
-    for (const part of head) {
-        const currentDefinition = current[part];
-        if (!currentDefinition || !('properties' in currentDefinition)) {
-            throw new Error(`Field "${field}" not found in mappings`);
-        }
-        current = currentDefinition.properties;
-    }
-    if (!current[tail]) {
-        throw new Error(`Field "${field}" not found in mappings`);
-    }
-    return current[tail];
-};
-const getFieldType = (context, field) => {
-    const definition = getFieldDefinition(context, field);
-    return definition.type;
-};
-const matchNested = (context, nested) => {
-    const nestedPath = nested.path;
-    const nestedDocuments = resolveField(context, nestedPath);
-    if (!Array.isArray(nestedDocuments)) {
-        throw new InvalidRequestError(`Nested path "${nestedPath}" is not an array`);
-    }
-    return nestedDocuments.some(nestedDocument => matchClause({
-        ...context,
-        scope: nestedPath,
-        document: nestedDocument
-    }, nested.query));
-};
-const matchExists = (context, exists) => {
-    const value = resolveField(context, exists.field);
-    return value !== undefined && value !== null;
-};
-const matchTerms = (context, terms) => {
-    for (const key in terms) {
-        const docValues = coerceArray(resolveField(context, key));
-        const coerceValue = getFieldType(context, key) === 'boolean'
-            ? (input) => {
-                if ([true, 'true', '1', 1].includes(input)) {
-                    return true;
-                }
-                if ([false, 'false', '0', 0, ''].includes(input)) {
-                    return false;
-                }
-                throw new InvalidRequestError('input is not a valid boolean filter');
-            }
-            : (x) => x;
-        const hasMatch = coerceArray(terms[key]).map(coerceValue).some(v => docValues.includes(v));
-        if (!hasMatch) {
-            return false;
-        }
-    }
-    return true;
-};
-const matchClause = (context, clause) => {
-    const filter = ('key' in clause && 'value' in clause)
-        ? { terms: { [clause.key]: clause.value } }
-        : clause;
-    if ('terms' in filter)
-        return matchTerms(context, filter.terms);
-    else if ('term' in filter)
-        return matchTerms(context, filter.term);
-    else if ('exists' in filter)
-        return matchExists(context, filter.exists);
-    else if ('bool' in filter)
-        return matchBool(context, filter.bool);
-    else if ('nested' in filter)
-        return matchNested(context, filter.nested);
-    else
-        throw new InvalidRequestError('invalid filter type');
-};
-const matchFilters = (context, filters, matchType) => {
-    for (const field of filters) {
-        const hasMatch = matchClause(context, field);
-        if ((matchType === MatchType.Must && !hasMatch) || (matchType === MatchType.MustNot && hasMatch)) {
-            return false;
-        }
-        else if (matchType === MatchType.Should && hasMatch) {
-            return true;
-        }
-    }
-    return matchType !== MatchType.Should;
-};
-const matchBool = (context, filters) => {
-    const { must_not, should, must, filter } = filters;
-    if ((must === null || must === void 0 ? void 0 : must.length) && !matchFilters(context, must, MatchType.Must)) {
-        return false;
-    }
-    if ((filter === null || filter === void 0 ? void 0 : filter.length) && !matchFilters(context, filter, MatchType.Must)) {
-        return false;
-    }
-    if ((must_not === null || must_not === void 0 ? void 0 : must_not.length) && !matchFilters(context, must_not, MatchType.MustNot)) {
-        return false;
-    }
-    if ((should === null || should === void 0 ? void 0 : should.length) && !matchFilters(context, should, MatchType.Should)) {
-        return false;
-    }
-    return true;
-};
-export const memorySearchTheBadWay = () => ({ store, mappings }) => {
-    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,
-        bulkIndex: async (_items) => undefined,
-        search: async (options) => {
-            const results = (await store.loadAllDocumentsTheBadWay())
-                .map(document => {
-                let weight = 0;
-                if (options.query !== undefined) {
-                    for (const field of options.fields) {
-                        if (field.type !== undefined && field.type !== 'text') {
-                            continue;
-                        }
-                        const value = resolveField({ document, fields: mappings, scope: '' }, field.key);
-                        if (value === undefined || value === null) {
-                            continue;
-                        }
-                        if (typeof value === 'string') {
-                            if (value.toUpperCase().indexOf(options.query.toUpperCase()) !== -1) {
-                                weight += (1 * field.weight);
-                            }
-                        }
-                        else {
-                            throw new Error(`invalid value type when searching in field ${field.key.toString()}`);
-                        }
-                    }
-                }
-                if (!matchBool({ document, fields: mappings, scope: '' }, options)) {
-                    return undefined;
-                }
-                return { document, weight };
-            })
-                .filter(isDefined)
-                .filter(r => !options.query || r.weight >= MIN_MATCH);
-            results.sort((a, b) => {
-                for (const sort of (options.sort || [])) {
-                    const aValue = resolveField({ document: a.document, fields: mappings, scope: '' }, sort.key);
-                    const bValue = resolveField({ document: b.document, fields: mappings, scope: '' }, 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 {
-                items: results.slice(offset, offset + MAX_RESULTS).map(r => r.document),
-                pageSize: MAX_RESULTS,
-                currentPage: page,
-                totalItems: results.length,
-                totalPages: Math.ceil(results.length / MAX_RESULTS)
-            };
-        },
-    };
-};

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

@@ -1,28 +0,0 @@
-import { ConfigProviderForConfig } from '../../config';
-import { FieldMappings, IndexOptions, SearchOptions } from '.';
-export type Config = {
-    node: string;
-    region: string;
-};
-export interface Initializer<C> {
-    configSpace?: C;
-}
-export type IndexConfig = {
-    name: string;
-    mappings: FieldMappings;
-    pageSize?: number;
-};
-export declare const openSearchService: <C extends string = "deployed">(initializer?: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <T>(indexConfig: IndexConfig) => {
-    ensureIndexCreated: () => Promise<void>;
-    deleteIndexIfExists: () => Promise<void>;
-    index: (params: IndexOptions<T>) => Promise<void>;
-    bulkIndex: (items: IndexOptions<T>[]) => Promise<void>;
-    search: (options: SearchOptions) => Promise<{
-        items: Exclude<T, undefined>[];
-        pageSize: number;
-        currentPage: number;
-        totalItems: number;
-        totalPages: number;
-    }>;
-    updateMappings: () => Promise<void>;
-};

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

@@ -1,150 +0,0 @@
-// cspell:ignore opensearch, Sigv
-import { defaultProvider } from '@aws-sdk/credential-provider-node';
-import { Client } from '@opensearch-project/opensearch';
-import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';
-import { resolveConfigValue } from '../../config';
-import { ifDefined, isDefined } from '../../guards';
-import { once } from '../../misc/helpers';
-const mapFilter = (filter) => {
-    if ('key' in filter && 'value' in filter) {
-        const { key } = filter;
-        const values = filter.value instanceof Array ? filter.value : [filter.value];
-        return { terms: { [key]: values } };
-    }
-    else {
-        return filter;
-    }
-};
-export const openSearchService = (initializer = {}) => (configProvider) => {
-    const config = configProvider[ifDefined(initializer.configSpace, 'deployed')];
-    const client = once(async () => new Client({
-        ...AwsSigv4Signer({
-            getCredentials: () => defaultProvider()(),
-            region: await resolveConfigValue(config.region),
-            service: 'es',
-        }),
-        maxRetries: 4, // default is 3
-        requestTimeout: 5000, // default is 30000
-        pingTimeout: 2000, // default is 30000
-        node: await resolveConfigValue(config.node),
-    }));
-    return (indexConfig) => {
-        const pageSize = indexConfig.pageSize || 10;
-        const deleteIndexIfExists = async () => {
-            const { indices } = await client();
-            const index = indexConfig.name;
-            const { body } = await indices.exists({ index });
-            if (body) {
-                await indices.delete({ index });
-            }
-        };
-        const ensureIndexCreated = async () => {
-            const { indices } = await client();
-            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();
-            await openSearchClient.index({
-                index: indexConfig.name,
-                body: params.body,
-                id: params.id,
-                refresh: true
-            }, {
-                requestTimeout: 10000,
-                maxRetries: 1,
-            });
-        };
-        const bulkIndex = async (items) => {
-            const openSearchClient = await client();
-            await openSearchClient.bulk({
-                index: indexConfig.name,
-                body: items.flatMap((item) => [
-                    { index: { _id: item.id } },
-                    item.body
-                ]),
-                refresh: true
-            }, {
-                requestTimeout: 10000,
-                maxRetries: 1,
-            });
-        };
-        const search = async (options) => {
-            var _a;
-            const body = {
-                query: { bool: {} },
-                track_total_hits: true,
-                size: pageSize
-            };
-            if (options.query) {
-                body.query.bool.must = [{
-                        multi_match: {
-                            fields: options.fields.map((field) => 'weight' in field ? `${field.key}^${field.weight}` : field.key),
-                            query: options.query
-                        }
-                    }];
-            }
-            const { must_not, should, must, filter } = options;
-            if (filter && filter.length > 0) {
-                body.query.bool.filter = filter.map(mapFilter);
-            }
-            if (must && must.length > 0) {
-                (_a = body.query.bool).must || (_a.must = []);
-                body.query.bool.must = body.query.bool.must.concat(must.map(mapFilter));
-            }
-            if (must_not && must_not.length > 0) {
-                body.query.bool.must_not = must_not.map(mapFilter);
-            }
-            if (should && should.length > 0) {
-                body.query.bool.should = should.map(mapFilter);
-                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.from = (options.page - 1) * pageSize;
-            }
-            const response = await (await client()).search({
-                body,
-                index: indexConfig.name
-            });
-            if (response.statusCode !== 200) {
-                throw new Error(`Unexpected status code: ${response.statusCode} from OpenSearch`);
-            }
-            const hits = response.body.hits;
-            const items = hits.hits.map((hit) => hit._source).filter(isDefined);
-            const currentPage = options.page || 1;
-            const { total } = hits;
-            const totalItems = typeof total === 'number' ? total : total.value;
-            const totalPages = Math.ceil(totalItems / pageSize) || 1;
-            return { items, pageSize, currentPage, totalItems, totalPages };
-        };
-        const updateMappings = async () => {
-            const { indices } = await client();
-            await indices.putMapping({
-                index: indexConfig.name,
-                body: {
-                    properties: indexConfig.mappings
-                }
-            }, {
-                requestTimeout: 10000,
-                maxRetries: 1,
-            });
-        };
-        return { ensureIndexCreated, deleteIndexIfExists, index, bulkIndex, search, updateMappings };
-    };
-};