@openstax/ts-utils 1.30.3 → 1.31.0

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

@@ -38,7 +38,7 @@ export type ApiClientResponse<Ro> = Ro extends any ? {
 } : never;
 export type ExpandRoute<T> = T extends ((...args: infer A) => infer R) & {
     renderUrl: (...args: infer Ar) => Promise<string>;
-} ? ((...args: A) => R) & {
+} ? (...args: A) => R & {
     renderUrl: (...args: Ar) => Promise<string>;
 } : never;
 export type MapRoutesToClient<Ru> = [Ru] extends [AnyRoute<Ru>] ? {

package/dist/esm/services/documentStore/fileSystemAssert.d.ts

@@ -0,0 +1 @@
+export declare const assertNoUndefined: (obj: any, path?: string[]) => void;

package/dist/esm/services/documentStore/fileSystemAssert.js

@@ -0,0 +1,10 @@
+export const assertNoUndefined = (obj, path = []) => {
+    if (obj === undefined) {
+        throw new Error(`unknown attribute type ${typeof obj} with value ${obj} at ${path.join('.') || 'root'}.`);
+    }
+    if (obj && typeof obj === 'object') {
+        for (const [key, value] of Object.entries(obj)) {
+            assertNoUndefined(value, [...path, key]);
+        }
+    }
+};

package/dist/esm/services/documentStore/unversioned/file-system.js

@@ -4,6 +4,7 @@ import { hashValue } from '../../..';
 import { resolveConfigValue } from '../../../config';
 import { ConflictError, NotFoundError } from '../../../errors';
 import { ifDefined, isDefined } from '../../../guards';
+import { assertNoUndefined } from '../fileSystemAssert';
 export const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
     const tableName = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem'].tableName);
     const tablePath = tableName.then((table) => path.join(initializer.dataDir, table));
@@ -42,6 +43,7 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
     return {
         loadAllDocumentsTheBadWay,
         getItemsByField: async (key, value, pageKey) => {
+            assertNoUndefined(value, [key]);
             const pageSize = 10;
             const items = await loadAllDocumentsTheBadWay();
             const filteredItems = items.filter((item) => item[key] === value);
@@ -53,11 +55,18 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             return { items: paginatedItems, nextPageToken };
         },
         batchGetItem: async (ids) => {
-            const items = await Promise.all(ids.map((id) => load(hashFilename(id))));
+            const items = await Promise.all(ids.map((id) => {
+                assertNoUndefined(id, ['id']);
+                return load(hashFilename(id));
+            }));
             return items.filter(isDefined);
         },
-        getItem: (id) => load(hashFilename(id)),
+        getItem: (id) => {
+            assertNoUndefined(id, ['id']);
+            return load(hashFilename(id));
+        },
         incrementItemAttribute: async (id, attribute) => {
+            assertNoUndefined(id, ['id']);
             const filename = hashFilename(id);
             const path = await filePath(filename);
             await mkTableDir;
@@ -88,11 +97,13 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
                 throw new NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
             }
             const newItem = { ...data, ...item };
+            assertNoUndefined(newItem);
             return new Promise((resolve, reject) => {
                 writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newItem));
             });
         },
         putItem: async (item) => {
+            assertNoUndefined(item);
             const path = await filePath(hashFilename(item[hashKey]));
             await mkTableDir;
             return new Promise((resolve, reject) => {
@@ -100,6 +111,7 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             });
         },
         createItem: async (item) => {
+            assertNoUndefined(item);
             const hashed = hashFilename(item[hashKey]);
             const existingItem = await load(hashed);
             if (existingItem) {
@@ -120,6 +132,7 @@ export const fileSystemUnversionedDocumentStore = (initializer) => () => (config
             // Process items sequentially to ensure consistent conflict detection
             // Note: concurrency parameter is ignored for filesystem to avoid race conditions
             for (const item of items) {
+                assertNoUndefined(item);
                 try {
                     const hashed = hashFilename(item[hashKey]);
                     const existingItem = await load(hashed);

package/dist/esm/services/documentStore/versioned/file-system.js

@@ -1,3 +1,4 @@
+import { assertNoUndefined } from '../fileSystemAssert';
 import { fileSystemUnversionedDocumentStore } from '../unversioned/file-system';
 const PAGE_LIMIT = 5;
 export const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
@@ -9,6 +10,7 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
             }));
         },
         getVersions: async (id, startVersion) => {
+            assertNoUndefined(id, ['id']);
             const item = await unversionedDocuments.getItem(id);
             const versions = item === null || item === void 0 ? void 0 : item.items.reverse();
             if (!versions) {
@@ -23,6 +25,7 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
             };
         },
         getItem: async (id, timestamp) => {
+            assertNoUndefined(id, ['id']);
             const item = await unversionedDocuments.getItem(id);
             if (timestamp) {
                 return item === null || item === void 0 ? void 0 : item.items.find(version => version.timestamp === timestamp);
@@ -38,6 +41,7 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
                 save: async (changes) => {
                     var _a;
                     const document = { ...item, ...changes, timestamp, author };
+                    assertNoUndefined(document);
                     const container = (_a = await unversionedDocuments.getItem(document[hashKey])) !== null && _a !== void 0 ? _a : { id: document[hashKey], items: [] };
                     const updated = { ...container, items: [...container.items, document] };
                     await unversionedDocuments.putItem(updated);
@@ -49,6 +53,7 @@ export const fileSystemVersionedDocumentStore = (initializer) => () => (configPr
             var _a;
             const author = (options === null || options === void 0 ? void 0 : options.getAuthor) ? await options.getAuthor(...authorArgs) : authorArgs[0];
             const document = { ...item, timestamp: new Date().getTime(), author };
+            assertNoUndefined(document);
             const container = (_a = await unversionedDocuments.getItem(document[hashKey])) !== null && _a !== void 0 ? _a : { id: document[hashKey], items: [] };
             const updated = { ...container, items: [...container.items, document] };
             await unversionedDocuments.putItem(updated);

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

@@ -14,16 +14,5 @@ export interface FileServerAdapter {
     putFileContent: (source: FileValue, content: string) => Promise<FileValue>;
     getSignedViewerUrl: (source: FileValue) => Promise<string>;
     getFileContent: (source: FileValue) => Promise<Buffer>;
-    getSignedFileUploadConfig: () => Promise<{
-        url: string;
-        payload: {
-            [key: string]: string;
-        };
-    }>;
-    copyFileTo: (source: FileValue, destinationPath: string) => Promise<FileValue>;
-    copyFileToDirectory: (source: FileValue, destinationDirectory: string) => Promise<FileValue>;
-    isTemporaryUpload: (source: FileValue) => boolean;
-    getFileChecksum: (source: FileValue) => Promise<string>;
-    filesEqual: (sourceA: FileValue, sourceB: FileValue) => Promise<boolean>;
 }
 export declare const isFileOrFolder: (thing: any) => thing is FileValue | FolderValue;

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

@@ -1,18 +1,16 @@
 /* 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';
-import { memoize } from '../../misc/helpers';
+import { once } from '../../misc/helpers';
 /* istanbul ignore next */
-const startServer = memoize((port, uploadDir) => {
+const startServer = once((port, uploadDir) => {
     // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does
     const upload = multer({ dest: uploadDir, preservePath: true });
     const fileServerApp = express();
@@ -68,54 +66,9 @@ 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.js

@@ -1,9 +1,6 @@
 /* cspell:ignore presigner */
-import { CopyObjectCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import { createPresignedPost } from '@aws-sdk/s3-presigned-post';
+import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
 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';
@@ -44,73 +41,9 @@ 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/lrsGateway/xapiUtils.d.ts

@@ -3,11 +3,15 @@ import { AuthProvider } from '../authProvider';
 import { ActivityState } from './attempt-utils';
 import { LrsGateway } from '.';
 export interface Grade {
-    scoreGiven: number;
-    scoreMaximum: number;
-    comment?: string;
     activityProgress: 'Initialized' | 'Started' | 'inProgress' | 'Submitted' | 'Completed';
+    comment?: string;
     gradingProgress: 'FullyGraded' | 'Pending' | 'PendingManual' | 'Failed' | 'NotReady';
+    scoreGiven: number;
+    scoreMaximum: number;
+    submission?: {
+        startedAt?: string;
+        submittedAt?: string;
+    };
     userId?: string;
 }
 export declare const getRegistrationAttemptInfo: (lrs: LrsGateway, registration: string, options?: {
@@ -24,7 +28,12 @@ export declare const getScoreGrade: (score: {
     raw?: number;
     min?: number;
     max?: number;
-}, completed: boolean, userId?: string, maxScore?: number) => Grade;
+}, options: {
+    maxScore?: number;
+    startedAt?: string;
+    submittedAt?: string;
+    userId?: string;
+}) => Grade;
 export type Progress = {
     scaled: number;
     max?: number;

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

@@ -22,29 +22,44 @@ export const getRegistrationAttemptInfo = async (lrs, registration, options) =>
 // 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
-export const getScoreGrade = (score, completed, userId, maxScore) => {
+// 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: completed ? 'Completed' : 'Started',
+        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;
+    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) || {}, !!state.currentAttemptCompleted, userId, scoreMaximum),
+        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,
         },