@openstax/ts-utils 1.29.0 → 1.30.1

package/dist/esm/services/fileServer/localFileServer.js

@@ -1,10 +1,12 @@
 /* cspell:ignore originalname */
+import crypto from 'crypto';
 import fs from 'fs';
 import https from 'https';
 import path from 'path';
 import cors from 'cors';
 import express from 'express';
 import multer from 'multer';
+import { v4 as uuid } from 'uuid';
 import { assertString } from '../../assertions';
 import { resolveConfigValue } from '../../config';
 import { ifDefined } from '../../guards';
@@ -66,9 +68,54 @@ export const localFileServer = (initializer) => (configProvider) => {
         await fs.promises.writeFile(filePath, content);
         return source;
     };
+    const getSignedFileUploadConfig = async () => {
+        const prefix = 'uploads/' + uuid();
+        return {
+            url: `https://${await host}:${await port}/`,
+            payload: {
+                key: prefix + '/${filename}',
+            }
+        };
+    };
+    const copyFileTo = async (source, destinationPath) => {
+        const sourcePath = path.join(await fileDir, source.path);
+        const destPath = path.join(await fileDir, destinationPath);
+        const destDirectory = path.dirname(destPath);
+        await fs.promises.mkdir(destDirectory, { recursive: true });
+        await fs.promises.copyFile(sourcePath, destPath);
+        return {
+            ...source,
+            path: destinationPath
+        };
+    };
+    const copyFileToDirectory = async (source, destination) => {
+        const destinationPath = path.join(destination, source.label);
+        return copyFileTo(source, destinationPath);
+    };
+    const isTemporaryUpload = (source) => {
+        return source.path.indexOf('uploads/') === 0;
+    };
+    const getFileChecksum = async (source) => {
+        const filePath = path.join(await fileDir, source.path);
+        const fileContent = await fs.promises.readFile(filePath);
+        return crypto.createHash('md5').update(fileContent).digest('hex');
+    };
+    const filesEqual = async (sourceA, sourceB) => {
+        const [aSum, bSum] = await Promise.all([
+            getFileChecksum(sourceA),
+            getFileChecksum(sourceB)
+        ]);
+        return aSum === bSum;
+    };
     return {
         getSignedViewerUrl,
         getFileContent,
         putFileContent,
+        getSignedFileUploadConfig,
+        copyFileTo,
+        copyFileToDirectory,
+        isTemporaryUpload,
+        getFileChecksum,
+        filesEqual,
     };
 };

package/dist/esm/services/fileServer/s3FileServer.d.ts

@@ -1,7 +1,7 @@
 import { S3Client } from '@aws-sdk/client-s3';
 import { ConfigProviderForConfig } from '../../config';
 import { FileServerAdapter } from '.';
-export declare type Config = {
+export type Config = {
     bucketName: string;
     bucketRegion: string;
 };
@@ -9,8 +9,5 @@ interface Initializer<C> {
     configSpace?: C;
     getS3Client?: (...args: ConstructorParameters<typeof S3Client>) => S3Client;
 }
-export declare const s3FileServer: <C extends string = "deployed">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    bucketName: import("../../config").ConfigValueProvider<string>;
-    bucketRegion: import("../../config").ConfigValueProvider<string>;
-}; }) => FileServerAdapter;
+export declare const s3FileServer: <C extends string = "deployed">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => FileServerAdapter;
 export {};

package/dist/esm/services/fileServer/s3FileServer.js

@@ -1,6 +1,9 @@
 /* cspell:ignore presigner */
-import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { CopyObjectCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { createPresignedPost } from '@aws-sdk/s3-presigned-post';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import path from 'path';
+import { v4 as uuid } from 'uuid';
 import { once } from '../..';
 import { assertDefined } from '../../assertions';
 import { resolveConfigValue } from '../../config';
@@ -41,9 +44,73 @@ export const s3FileServer = (initializer) => (configProvider) => {
         await (await s3Service()).send(command);
         return source;
     };
+    /*
+     * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_s3_presigned_post.html
+     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/HTTPPOSTExamples.html
+     * https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-post-example.html
+     */
+    const getSignedFileUploadConfig = async () => {
+        const prefix = 'uploads/' + uuid();
+        const bucket = (await bucketName());
+        const Conditions = [
+            { acl: 'private' },
+            { bucket },
+            ['starts-with', '$key', prefix]
+        ];
+        const defaultFields = {
+            acl: 'private',
+        };
+        const { url, fields } = await createPresignedPost(await s3Service(), {
+            Bucket: bucket,
+            Key: prefix + '/${filename}',
+            Conditions,
+            Fields: defaultFields,
+            Expires: 3600, // 1 hour 
+        });
+        return {
+            url, payload: fields
+        };
+    };
+    const copyFileTo = async (source, destinationPath) => {
+        const bucket = (await bucketName());
+        const destinationPathWithoutLeadingSlash = destinationPath.replace(/^\//, '');
+        const command = new CopyObjectCommand({
+            Bucket: bucket,
+            Key: destinationPathWithoutLeadingSlash,
+            CopySource: path.join(bucket, source.path),
+        });
+        await (await s3Service()).send(command);
+        return {
+            ...source,
+            path: destinationPathWithoutLeadingSlash
+        };
+    };
+    const copyFileToDirectory = async (source, destination) => {
+        const destinationPath = path.join(destination, source.label);
+        return copyFileTo(source, destinationPath);
+    };
+    const isTemporaryUpload = (source) => {
+        return source.path.indexOf('uploads/') === 0;
+    };
+    const getFileChecksum = async (source) => {
+        const bucket = (await bucketName());
+        const command = new HeadObjectCommand({ Bucket: bucket, Key: source.path });
+        const response = await (await s3Service()).send(command);
+        return assertDefined(response.ETag);
+    };
+    const filesEqual = async (sourceA, sourceB) => {
+        const [aSum, bSum] = await Promise.all([getFileChecksum(sourceA), getFileChecksum(sourceB)]);
+        return aSum === bSum;
+    };
     return {
         getFileContent,
         putFileContent,
         getSignedViewerUrl,
+        getSignedFileUploadConfig,
+        copyFileTo,
+        copyFileToDirectory,
+        isTemporaryUpload,
+        getFileChecksum,
+        filesEqual,
     };
 };

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

@@ -1,7 +1,7 @@
 import { JWK } from 'node-jose';
 import { ConfigProviderForConfig } from '../../config';
 import type { JsonCompatibleValue } from '../../routing';
-declare type Config = {
+type Config = {
     alg: string;
     expiresIn: string;
     iss: string;
@@ -13,16 +13,11 @@ interface Initializer<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>;
-}; }) => {
+export declare const createLaunchSigner: <C extends string = "launch">({ configSpace }: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => {
     jwks: () => Promise<{
         keys: JWK.RawKey[];
     }>;
-    sign: (data: Record<string, JsonCompatibleValue>, subject: string, maxExp?: number | null | undefined) => Promise<string>;
+    sign: (data: Record<string, JsonCompatibleValue>, subject: string, maxExp?: number | null) => Promise<string>;
 };
-export declare type LaunchSigner = ReturnType<ReturnType<typeof createLaunchSigner>>;
+export type LaunchSigner = ReturnType<ReturnType<typeof createLaunchSigner>>;
 export {};

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

@@ -1,7 +1,7 @@
 import jwt from 'jsonwebtoken';
 import type { JWK } from 'node-jose';
 import { ConfigProviderForConfig } from '../../config';
-declare type Config = {
+type Config = {
     trustedDomain: string;
     bypassSignatureVerification: string;
 };
@@ -14,11 +14,8 @@ interface Initializer<C> {
 /**
  * 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>;
-    bypassSignatureVerification: import("../../config").ConfigValueProvider<string>;
-}; }) => (_services: {}, getDefaultToken?: (() => string) | undefined) => {
-    verify: <T = undefined>(...args: T extends undefined ? [] | [string] : [(input: any) => T] | [string, (input: any) => T]) => Promise<T extends undefined ? jwt.JwtPayload : T>;
+export declare const createLaunchVerifier: <C extends string = "launch">({ configSpace, fetcher }: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => (_services: {}, getDefaultToken?: () => string) => {
+    verify: <T = undefined>(...args: T extends undefined ? ([] | [string]) : ([(input: any) => T] | [string, (input: any) => T])) => Promise<T extends undefined ? jwt.JwtPayload : T>;
 };
-export declare type LaunchVerifier = ReturnType<ReturnType<ReturnType<typeof createLaunchVerifier>>>;
+export type LaunchVerifier = ReturnType<ReturnType<ReturnType<typeof createLaunchVerifier>>>;
 export {};

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

@@ -13,7 +13,7 @@ export declare enum Level {
  * @param level - log level
  * @param event - event to log
  */
-export declare type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
+export type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
 /**
  * A logger that can be used to log events.
  *
@@ -36,4 +36,4 @@ export interface Logger {
  *   (the context is returned when messages are logged with the logger)
  * @returns a Logger
  */
-export declare const createCoreLogger: (driver: LogEvent, getParentContext?: (() => JsonCompatibleStruct) | undefined) => Logger;
+export declare const createCoreLogger: (driver: LogEvent, getParentContext?: () => JsonCompatibleStruct) => Logger;

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

@@ -1,5 +1,5 @@
 import { User } from '../authProvider';
 import { EagerXapiStatement, UXapiStatement, XapiStatement } from '.';
-export declare const addStatementDefaultFields: (statement: (Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+export declare const addStatementDefaultFields: (statement: (Pick<XapiStatement, "object" | "verb" | "context" | "result"> & {
     id?: string;
 }) | UXapiStatement, user: User) => EagerXapiStatement;

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

@@ -1,5 +1,5 @@
 import { LrsGateway, UXapiStatement } from '.';
-export declare type ActivityState = {
+export type ActivityState = {
     attempts: number;
     completedAttempts: number;
     currentAttempt?: UXapiStatement;
@@ -11,60 +11,60 @@ export declare type ActivityState = {
 export declare const matchAttempt: (statement: UXapiStatement) => boolean;
 export declare const matchAttemptCompleted: (attempt: UXapiStatement) => (statement: UXapiStatement) => boolean;
 export declare const resolveAttempts: (statements: UXapiStatement[], options?: {
-    activityIRI?: string | undefined;
-    parentActivityAttempt?: string | undefined;
-} | undefined) => UXapiStatement[];
-export declare const resolveCompletedForAttempt: (statements: UXapiStatement[], attempt: UXapiStatement, activityIRI?: string | undefined) => UXapiStatement | undefined;
+    activityIRI?: string;
+    parentActivityAttempt?: string;
+}) => UXapiStatement[];
+export declare const resolveCompletedForAttempt: (statements: UXapiStatement[], attempt: UXapiStatement, activityIRI?: string) => UXapiStatement | undefined;
 export declare const oldestStatement: (statements: UXapiStatement[]) => UXapiStatement | undefined;
 export declare const mostRecentStatement: (statements: UXapiStatement[]) => UXapiStatement | undefined;
 export declare const resolveAttemptInfo: (statements: UXapiStatement[], options?: {
-    activityIRI?: string | undefined;
-    currentAttempt?: string | undefined;
-    parentActivityAttempt?: string | undefined;
-    currentPreference?: "latest" | "oldest" | undefined;
-} | undefined) => ActivityState;
+    activityIRI?: string;
+    currentAttempt?: string;
+    parentActivityAttempt?: string;
+    currentPreference?: "latest" | "oldest";
+}) => ActivityState;
 export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGateway, activityIRI: string, options?: {
-    anyUser?: boolean | undefined;
-    attempt?: string | undefined;
-    ensureSync?: boolean | undefined;
-    user?: string | undefined;
-} | undefined) => Promise<import(".").XapiStatement[]>;
+    anyUser?: boolean;
+    attempt?: string;
+    ensureSync?: boolean;
+    user?: string;
+}) => Promise<import(".").XapiStatement[]>;
 export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
-    currentAttempt?: string | undefined;
-    parentActivityAttempt?: string | undefined;
-    ensureSync?: boolean | undefined;
-} | undefined) => Promise<ActivityState>;
-export declare const createStatement: (verb: UXapiStatement['verb'], activity: {
+    currentAttempt?: string;
+    parentActivityAttempt?: string;
+    ensureSync?: boolean;
+}) => Promise<ActivityState>;
+export declare const createStatement: (verb: UXapiStatement["verb"], activity: {
     iri: string;
     type: string;
     name: string;
     extensions?: {
         [key: string]: string;
-    } | undefined;
-}, attempt: string, parentActivityIRI?: string | undefined) => Pick<UXapiStatement, 'object' | 'verb' | 'context'>;
+    };
+}, attempt: string, parentActivityIRI?: string) => Pick<UXapiStatement, "object" | "verb" | "context">;
 export declare const createAttemptStatement: (activity: {
     iri: string;
     type: string;
     name: string;
     extensions?: {
         [key: string]: string;
-    } | undefined;
+    };
 }, parentActivity?: {
-    iri?: string | undefined;
-    attempt?: string | undefined;
-} | undefined) => Pick<UXapiStatement, 'object' | 'verb' | 'context'>;
+    iri?: string;
+    attempt?: string;
+}) => Pick<UXapiStatement, "object" | "verb" | "context">;
 export declare const putAttemptStatement: (gateway: LrsGateway, activity: {
     iri: string;
     type: string;
     name: string;
     extensions?: {
         [key: string]: string;
-    } | undefined;
+    };
 }, parentActivity?: {
-    iri?: string | undefined;
-    attempt?: string | undefined;
-} | undefined) => Promise<import(".").EagerXapiStatement>;
-export declare const createAttemptActivityStatement: (attemptStatement: UXapiStatement, verb: UXapiStatement['verb'], result?: UXapiStatement['result']) => Pick<UXapiStatement, 'object' | 'verb' | 'context' | 'result'>;
-export declare const putAttemptActivityStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, verb: UXapiStatement['verb'], result?: UXapiStatement['result']) => Promise<import(".").EagerXapiStatement>;
-export declare const createCompletedStatement: (attemptStatement: UXapiStatement, result?: UXapiStatement['result']) => Pick<UXapiStatement, 'object' | 'verb' | 'context' | 'result'>;
-export declare const putCompletedStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement['result']) => Promise<import(".").EagerXapiStatement>;
+    iri?: string;
+    attempt?: string;
+}) => Promise<import(".").EagerXapiStatement>;
+export declare const createAttemptActivityStatement: (attemptStatement: UXapiStatement, verb: UXapiStatement["verb"], result?: UXapiStatement["result"]) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
+export declare const putAttemptActivityStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, verb: UXapiStatement["verb"], result?: UXapiStatement["result"]) => Promise<import(".").EagerXapiStatement>;
+export declare const createCompletedStatement: (attemptStatement: UXapiStatement, result?: UXapiStatement["result"]) => Pick<UXapiStatement, "object" | "verb" | "context" | "result">;
+export declare const putCompletedStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement["result"]) => Promise<import(".").EagerXapiStatement>;

package/dist/esm/services/lrsGateway/file-system.d.ts

@@ -1,7 +1,7 @@
 import { ConfigProviderForConfig } from '../../config';
 import { AuthProvider } from '../authProvider';
 import { LrsGateway } from '.';
-declare type Config = {
+type Config = {
     name: string;
 };
 interface Initializer<C> {
@@ -9,9 +9,7 @@ interface Initializer<C> {
     fs?: Pick<typeof import('fs'), 'readFile' | 'writeFile'>;
     configSpace?: C;
 }
-export declare const fileSystemLrsGateway: <C extends string = "fileSystem">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    name: import("../../config").ConfigValueProvider<string>;
-}; }) => ({ authProvider }: {
+export declare const fileSystemLrsGateway: <C extends string = "fileSystem">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => ({ authProvider }: {
     authProvider: AuthProvider;
 }) => LrsGateway;
 export {};

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

@@ -3,7 +3,7 @@ import { GenericFetch } from '../../fetch';
 import { WithRequired } from '../../types';
 import { AuthProvider } from '../authProvider';
 import { Logger } from '../logger';
-declare type Config = {
+type Config = {
     lrsHost: string;
     lrsAuthorization: string;
 };
@@ -73,32 +73,29 @@ export interface XapiStatement {
     timestamp: string;
     stored?: string;
 }
-export declare type SavedXapiStatement = WithRequired<XapiStatement, 'stored'>;
-export declare type EagerXapiStatement = Omit<XapiStatement, 'stored'>;
-export declare type UXapiStatement = XapiStatement | EagerXapiStatement | SavedXapiStatement;
-export declare type LrsGateway = ReturnType<ReturnType<ReturnType<typeof lrsGateway>>>;
-export declare type LrsProvider = ReturnType<ReturnType<typeof lrsGateway>>;
-export declare const lrsGateway: <C extends string = "lrs">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
-    lrsHost: import("../../config").ConfigValueProvider<string>;
-    lrsAuthorization: import("../../config").ConfigValueProvider<string>;
-}; }) => ({ authProvider, logger }: {
+export type SavedXapiStatement = WithRequired<XapiStatement, 'stored'>;
+export type EagerXapiStatement = Omit<XapiStatement, 'stored'>;
+export type UXapiStatement = XapiStatement | EagerXapiStatement | SavedXapiStatement;
+export type LrsGateway = ReturnType<ReturnType<ReturnType<typeof lrsGateway>>>;
+export type LrsProvider = ReturnType<ReturnType<typeof lrsGateway>>;
+export declare const lrsGateway: <C extends string = "lrs">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => ({ authProvider, logger }: {
     authProvider: AuthProvider;
     logger: Logger;
 }) => {
-    putXapiStatements: (statements: Array<(Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+    putXapiStatements: (statements: Array<(Pick<XapiStatement, "object" | "verb" | "context" | "result"> & {
         id?: string;
     }) | UXapiStatement>) => Promise<EagerXapiStatement[]>;
     getXapiStatements: (params: {
-        verb?: string | undefined;
-        activity?: string | undefined;
-        registration?: string | undefined;
-        related_activities?: boolean | undefined;
-        user?: string | undefined;
-        anyUser?: boolean | undefined;
-        since?: string | undefined;
-        until?: string | undefined;
+        verb?: string;
+        activity?: string;
+        registration?: string;
+        related_activities?: boolean;
+        user?: string;
+        anyUser?: boolean;
+        since?: string;
+        until?: string;
     } & {
-        ensureSync?: boolean | undefined;
+        ensureSync?: boolean;
     }) => Promise<{
         more: string;
         statements: XapiStatement[];
@@ -107,19 +104,19 @@ export declare const lrsGateway: <C extends string = "lrs">(initializer: Initial
         more: string;
         statements: XapiStatement[];
     }>;
-    getAllXapiStatements: ({ fetchUntil, ...params }: {
-        verb?: string | undefined;
-        activity?: string | undefined;
-        registration?: string | undefined;
-        related_activities?: boolean | undefined;
-        user?: string | undefined;
-        anyUser?: boolean | undefined;
-        since?: string | undefined;
-        until?: string | undefined;
-    } & {
-        ensureSync?: boolean | undefined;
+    getAllXapiStatements: ({ fetchUntil, ...params }: ({
+        verb?: string;
+        activity?: string;
+        registration?: string;
+        related_activities?: boolean;
+        user?: string;
+        anyUser?: boolean;
+        since?: string;
+        until?: string;
     } & {
-        fetchUntil?: ((statements: XapiStatement[]) => boolean) | undefined;
+        ensureSync?: boolean;
+    }) & {
+        fetchUntil?: (statements: XapiStatement[]) => boolean;
     }) => Promise<XapiStatement[]>;
 };
 export {};

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

@@ -11,12 +11,12 @@ export interface Grade {
     userId?: string;
 }
 export declare const getRegistrationAttemptInfo: (lrs: LrsGateway, registration: string, options?: {
-    activity?: string | undefined;
-    anyUser?: boolean | undefined;
-    currentPreference?: "latest" | "oldest" | undefined;
-    ensureSync?: boolean | undefined;
-    user?: string | undefined;
-} | undefined) => Promise<{
+    activity?: string;
+    anyUser?: boolean;
+    currentPreference?: "latest" | "oldest";
+    ensureSync?: boolean;
+    user?: string;
+}) => Promise<{
     [key: string]: ActivityState;
 }>;
 export declare const getScoreGrade: (score: {
@@ -24,13 +24,13 @@ export declare const getScoreGrade: (score: {
     raw?: number;
     min?: number;
     max?: number;
-}, completed: boolean, userId?: string | undefined, maxScore?: number | undefined) => Grade;
-export declare type Progress = {
+}, completed: boolean, userId?: string, maxScore?: number) => Grade;
+export type Progress = {
     scaled: number;
     max?: number;
     raw?: number;
 };
-export declare type GradeAndProgress = {
+export type GradeAndProgress = {
     grade: Grade;
     progress: Progress;
     name?: string;
@@ -39,21 +39,21 @@ export declare const getCurrentGrade: (services: {
     lrs: LrsGateway;
     ltiAuthProvider: AuthProvider;
 }, registration: string, options?: {
-    currentPreference?: "latest" | "oldest" | undefined;
-    incompleteAttemptCallback?: ((info: ActivityState) => Promise<GradeAndProgress>) | undefined;
-    name?: string | undefined;
-    scoreMaximum?: number | undefined;
-    userId?: string | undefined;
-} | undefined) => Promise<GradeAndProgress | null>;
-export declare type UserActivityInfo = MappedUserInfo<ActivityState>;
+    currentPreference?: "latest" | "oldest";
+    incompleteAttemptCallback?: (info: ActivityState) => Promise<GradeAndProgress>;
+    name?: string;
+    scoreMaximum?: number;
+    userId?: string;
+}) => Promise<GradeAndProgress | null>;
+export type UserActivityInfo = MappedUserInfo<ActivityState>;
 export declare const getAssignmentGrades: (services: {
     accountsGateway: AccountsGateway;
     lrs: LrsGateway;
 }, assignmentIRI: string, registration: string, options?: {
-    anyUser?: boolean | undefined;
-    currentPreference?: "latest" | "oldest" | undefined;
-    incompleteAttemptsCallback?: ((mappedInfo: UserActivityInfo[]) => Promise<GradeAndProgress[]>) | undefined;
-    platformId?: string | undefined;
-    scoreMaximum?: number | undefined;
-    user?: string | undefined;
-} | undefined) => Promise<GradeAndProgress[]>;
+    anyUser?: boolean;
+    currentPreference?: "latest" | "oldest";
+    incompleteAttemptsCallback?: (mappedInfo: UserActivityInfo[]) => Promise<GradeAndProgress[]>;
+    platformId?: string;
+    scoreMaximum?: number;
+    user?: string;
+}) => Promise<GradeAndProgress[]>;

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

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

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

@@ -1,5 +1,5 @@
-export declare type FieldType = string | string[] | number | boolean;
-export declare type ESFilter = {
+export type FieldType = string | string[] | number | boolean;
+export type ESFilter = {
     terms: Record<string, FieldType>;
 } | {
     term: Record<string, FieldType>;
@@ -15,18 +15,18 @@ export declare type ESFilter = {
 } | {
     bool: BoolFilter;
 };
-export declare type Filter = {
+export type Filter = {
     key: string;
     value: FieldType;
 } | ESFilter;
-export declare type BoolFilter = {
+export type BoolFilter = {
     must?: Filter[];
     must_not?: Filter[];
     should?: Filter[];
     filter?: Filter[];
     minimum_should_match?: number;
 };
-declare type Field = {
+type Field = {
     key: string;
     type?: 'text';
     weight: number;
@@ -41,7 +41,7 @@ export interface IndexOptions<T> {
     body: T;
     id: string;
 }
-export declare type FieldMapping = {
+export type FieldMapping = {
     type: 'keyword' | 'text' | 'boolean';
 } | {
     type: 'date';
@@ -50,7 +50,7 @@ export declare type FieldMapping = {
     type?: 'nested' | 'object';
     properties: Record<string, FieldMapping>;
 };
-export declare type FieldMappings = Record<string, FieldMapping>;
+export type FieldMappings = Record<string, FieldMapping>;
 export interface SearchOptions {
     page?: number;
     query: string | undefined;

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

@@ -1,5 +1,5 @@
 import { FieldMappings, IndexOptions, SearchOptions } from '.';
-export declare type Config<T> = {
+export type Config<T> = {
     mappings: FieldMappings;
     store: {
         loadAllDocumentsTheBadWay: () => Promise<T[]>;

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

@@ -1,21 +1,18 @@
 import { ConfigProviderForConfig } from '../../config';
 import { FieldMappings, IndexOptions, SearchOptions } from '.';
-export declare type Config = {
+export type Config = {
     node: string;
     region: string;
 };
 export interface Initializer<C> {
     configSpace?: C;
 }
-export declare type IndexConfig = {
+export type IndexConfig = {
     name: string;
     mappings: FieldMappings;
     pageSize?: number;
 };
-export declare const openSearchService: <C extends string = "deployed">(initializer?: Initializer<C>) => (configProvider: { [key in C]: {
-    node: import("../../config").ConfigValueProvider<string>;
-    region: import("../../config").ConfigValueProvider<string>;
-}; }) => <T>(indexConfig: IndexConfig) => {
+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>;