@openstax/ts-utils 1.30.4 → 1.31.1

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/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,
         },