@openstax/ts-utils 1.41.0 → 1.41.3

package/dist/cjs/services/authProvider/subrequest.js

@@ -27,8 +27,7 @@ const subrequestAuthProvider = (initializer) => (configProvider) => {
                 return undefined;
             }
             const user = await (0, userSubrequest_1.loadUserData)(initializer.fetch, await accountsBase(), resolvedCookieName, token);
-            // this returns `{"error_id":null}` when the token is invalid
-            if (user.uuid) {
+            if (user) {
                 logger.setContext({ user: user.uuid });
                 return user;
             }

package/dist/cjs/services/authProvider/utils/userSubrequest.d.ts

@@ -1,3 +1,3 @@
 import { ApiUser } from '..';
 import { GenericFetch } from '../../../fetch';
-export declare const loadUserData: (fetch: GenericFetch, accountsBase: string, cookieName: string, token: string) => Promise<ApiUser>;
+export declare const loadUserData: (fetch: GenericFetch, accountsBase: string, cookieName: string, token: string) => Promise<ApiUser | undefined>;

package/dist/cjs/services/authProvider/utils/userSubrequest.js

@@ -7,7 +7,9 @@ exports.loadUserData = void 0;
 const cookie_1 = __importDefault(require("cookie"));
 const loadUserData = (fetch, accountsBase, cookieName, token) => {
     const headers = { cookie: cookie_1.default.serialize(cookieName, token) };
+    // this returns `{"error_id":null}` when the token is invalid
     return fetch(accountsBase.replace(/\/+$/, '') + '/api/user', { headers })
-        .then(response => response.json());
+        .then(response => response.json())
+        .then(data => ('error_id' in data ? undefined : data));
 };
 exports.loadUserData = loadUserData;

package/dist/cjs/services/documentStore/dynamoEncoding.js

@@ -15,7 +15,7 @@ const encodeDynamoAttribute = (value) => {
     if (value === null) {
         return { NULL: true };
     }
-    if (value instanceof Array) {
+    if (Array.isArray(value)) {
         return { L: value.map(exports.encodeDynamoAttribute) };
     }
     if ((0, guards_1.isPlainObject)(value)) {
@@ -24,7 +24,7 @@ const encodeDynamoAttribute = (value) => {
     throw new Error(`unknown attribute type ${typeof value} with value ${value}.`);
 };
 exports.encodeDynamoAttribute = encodeDynamoAttribute;
-const encodeDynamoDocument = (base) => Object.fromEntries(Object.entries(base).map(([key, value]) => ([key, (0, exports.encodeDynamoAttribute)(value)])));
+const encodeDynamoDocument = (base) => Object.fromEntries(Object.entries(base).filter(([, value]) => value !== undefined).map(([key, value]) => ([key, (0, exports.encodeDynamoAttribute)(value)])));
 exports.encodeDynamoDocument = encodeDynamoDocument;
 const decodeDynamoAttribute = (value) => {
     if (value.S !== undefined) {

package/dist/cjs/services/documentStore/unversioned/file-system.d.ts

@@ -8,7 +8,6 @@ interface Initializer<C> {
 export declare const fileSystemUnversionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends TDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T>(_: {}, hashKey: K, options?: {
     afterWrite?: (item: T) => void | Promise<void>;
     batchAfterWrite?: (items: T[]) => void | Promise<void>;
-    skipAssert?: boolean;
 }) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getItemsByField: (key: keyof T, value: T[K], pageKey?: string) => Promise<{

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

@@ -43,13 +43,10 @@ const __1 = require("../../..");
 const config_1 = require("../../../config");
 const errors_1 = require("../../../errors");
 const guards_1 = require("../../../guards");
-const fileSystemAssert_1 = require("../fileSystemAssert");
 const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
-    var _a;
     const tableName = (0, config_1.resolveConfigValue)(configProvider[initializer.configSpace || 'fileSystem'].tableName);
     const tablePath = tableName.then((table) => path_1.default.join(initializer.dataDir, table));
     const { mkdir, readdir, readFile, writeFile } = (0, guards_1.ifDefined)(initializer.fs, fsModule);
-    const skipAssert = (_a = options === null || options === void 0 ? void 0 : options.skipAssert) !== null && _a !== void 0 ? _a : false;
     const mkTableDir = new Promise((resolve, reject) => tablePath.then((path) => mkdir(path, { recursive: true }, (err) => err && err.code !== 'EEXIST' ? reject(err) : resolve())));
     const hashFilename = (value) => `${(0, __1.hashValue)(value)}.json`;
     const filePath = async (filename) => path_1.default.join(await tablePath, filename);
@@ -84,8 +81,6 @@ const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvide
     return {
         loadAllDocumentsTheBadWay,
         getItemsByField: async (key, value, pageKey) => {
-            if (!skipAssert)
-                (0, fileSystemAssert_1.assertNoUndefined)(value, [key]);
             const pageSize = 10;
             const items = await loadAllDocumentsTheBadWay();
             const filteredItems = items.filter((item) => item[key] === value);
@@ -98,20 +93,14 @@ const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvide
         },
         batchGetItem: async (ids) => {
             const items = await Promise.all(ids.map((id) => {
-                if (!skipAssert)
-                    (0, fileSystemAssert_1.assertNoUndefined)(id, ['id']);
                 return load(hashFilename(id));
             }));
             return items.filter(guards_1.isDefined);
         },
         getItem: (id) => {
-            if (!skipAssert)
-                (0, fileSystemAssert_1.assertNoUndefined)(id, ['id']);
             return load(hashFilename(id));
         },
         incrementItemAttribute: async (id, attribute) => {
-            if (!skipAssert)
-                (0, fileSystemAssert_1.assertNoUndefined)(id, ['id']);
             const filename = hashFilename(id);
             const path = await filePath(filename);
             await mkTableDir;
@@ -142,15 +131,11 @@ const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvide
                 throw new errors_1.NotFoundError(`Item with ${hashKey.toString()} "${id}" does not exist`);
             }
             const newItem = { ...data, ...item };
-            if (!skipAssert)
-                (0, fileSystemAssert_1.assertNoUndefined)(newItem);
             return new Promise((resolve, reject) => {
                 writeFile(path, JSON.stringify(newItem, null, 2), (err) => err ? reject(err) : resolve(newItem));
             });
         },
         putItem: async (item) => {
-            if (!skipAssert)
-                (0, fileSystemAssert_1.assertNoUndefined)(item);
             const path = await filePath(hashFilename(item[hashKey]));
             await mkTableDir;
             return new Promise((resolve, reject) => {
@@ -158,8 +143,6 @@ const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvide
             });
         },
         createItem: async (item) => {
-            if (!skipAssert)
-                (0, fileSystemAssert_1.assertNoUndefined)(item);
             const hashed = hashFilename(item[hashKey]);
             const existingItem = await load(hashed);
             if (existingItem) {
@@ -180,8 +163,6 @@ const fileSystemUnversionedDocumentStore = (initializer) => () => (configProvide
             // Process items sequentially to ensure consistent conflict detection
             // Note: concurrency parameter is ignored for filesystem to avoid race conditions
             for (const item of items) {
-                if (!skipAssert)
-                    (0, fileSystemAssert_1.assertNoUndefined)(item);
                 try {
                     const hashed = hashFilename(item[hashKey]);
                     const existingItem = await load(hashed);

package/dist/cjs/services/documentStore/versioned/file-system.d.ts

@@ -8,7 +8,6 @@ interface Initializer<C> {
 }
 export declare const fileSystemVersionedDocumentStore: <C extends string = "fileSystem">(initializer: Initializer<C>) => <T extends VersionedTDocument<T>>() => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => <K extends keyof T, A extends undefined | ((...a: any[]) => Promise<VersionedDocumentAuthor>)>(_: {}, hashKey: K, options?: {
     getAuthor?: A;
-    skipAssert?: boolean;
 }) => {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
     getVersions: (id: T[K], startVersion?: number) => Promise<{

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

@@ -1,13 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileSystemVersionedDocumentStore = void 0;
-const fileSystemAssert_1 = require("../fileSystemAssert");
 const file_system_1 = require("../unversioned/file-system");
 const PAGE_LIMIT = 5;
 const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider) => (_, hashKey, options) => {
-    var _a;
-    const skipAssert = (_a = options === null || options === void 0 ? void 0 : options.skipAssert) !== null && _a !== void 0 ? _a : false;
-    const unversionedDocuments = (0, file_system_1.fileSystemUnversionedDocumentStore)(initializer)()(configProvider)({}, 'id', { skipAssert });
+    const unversionedDocuments = (0, file_system_1.fileSystemUnversionedDocumentStore)(initializer)()(configProvider)({}, 'id');
     return {
         loadAllDocumentsTheBadWay: () => {
             return unversionedDocuments.loadAllDocumentsTheBadWay().then(documents => documents.map(document => {
@@ -15,8 +12,6 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
             }));
         },
         getVersions: async (id, startVersion) => {
-            if (!skipAssert)
-                (0, fileSystemAssert_1.assertNoUndefined)(id, ['id']);
             const item = await unversionedDocuments.getItem(id);
             const versions = item === null || item === void 0 ? void 0 : item.items.reverse();
             if (!versions) {
@@ -31,8 +26,6 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
             };
         },
         getItem: async (id, timestamp) => {
-            if (!skipAssert)
-                (0, fileSystemAssert_1.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);
@@ -48,8 +41,6 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
                 save: async (changes) => {
                     var _a;
                     const document = { ...item, ...changes, timestamp, author };
-                    if (!skipAssert)
-                        (0, fileSystemAssert_1.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);
@@ -61,8 +52,6 @@ const fileSystemVersionedDocumentStore = (initializer) => () => (configProvider)
             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 };
-            if (!skipAssert)
-                (0, fileSystemAssert_1.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/cjs/services/lrsGateway/batching.d.ts

@@ -0,0 +1,46 @@
+import { GenericFetch, Response } from '../../fetch';
+import { METHOD } from '../../routing';
+export interface BatchRequest {
+    id: string;
+    path: string;
+    method: METHOD;
+    queryParams?: Record<string, string>;
+    headers?: Record<string, string>;
+    body?: string;
+}
+export interface BatchResponse {
+    id: string;
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}
+interface BatcherConfig {
+    batchEndpoint: string;
+    getAuthHeader: () => Promise<string>;
+    getHost: () => Promise<string>;
+}
+/**
+ * Handles automatic request batching using microtask queue scheduling.
+ * Batches concurrent requests within the same event loop tick.
+ */
+export declare class RequestBatcher {
+    private fetcher;
+    private config;
+    private pendingRequests;
+    private flushScheduled;
+    private requestCounter;
+    constructor(fetcher: GenericFetch, config: BatcherConfig);
+    /**
+     * Queue a request for batching. Returns a promise that resolves with the response.
+     * Automatically flushes the batch on the next microtask.
+     */
+    queueRequest(options: Omit<BatchRequest, 'id'>): Promise<Response>;
+    singleRequest(options: Omit<BatchRequest, 'id'>): Promise<Response>;
+    /**
+     * Flush all pending requests. If only one request is pending, makes a direct HTTP call.
+     * Otherwise, sends a batch request to the batch API endpoint.
+     */
+    private flush;
+    private flushHandler;
+}
+export {};

package/dist/cjs/services/lrsGateway/batching.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestBatcher = void 0;
+const routing_1 = require("../../routing");
+/**
+ * Handles automatic request batching using microtask queue scheduling.
+ * Batches concurrent requests within the same event loop tick.
+ */
+class RequestBatcher {
+    constructor(fetcher, config) {
+        this.fetcher = fetcher;
+        this.config = config;
+        this.pendingRequests = [];
+        this.flushScheduled = false;
+        this.requestCounter = 0;
+    }
+    /**
+     * Queue a request for batching. Returns a promise that resolves with the response.
+     * Automatically flushes the batch on the next microtask.
+     */
+    queueRequest(options) {
+        const id = `req_${++this.requestCounter}`;
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.push({
+                ...options,
+                id, resolve, reject,
+            });
+            // Schedule microtask flush if not already scheduled
+            if (!this.flushScheduled) {
+                this.flushScheduled = true;
+                queueMicrotask(() => this.flush());
+            }
+        });
+    }
+    async singleRequest(options) {
+        const { path, method, queryParams, headers, body } = options;
+        const host = await this.config.getHost();
+        const query = new URLSearchParams(queryParams || {}).toString();
+        const url = host.replace(/\/+$/, '') + path + (query ? `?${query}` : '');
+        return await this.fetcher(url, { method, headers, body });
+    }
+    /**
+     * Flush all pending requests. If only one request is pending, makes a direct HTTP call.
+     * Otherwise, sends a batch request to the batch API endpoint.
+     */
+    flush() {
+        this.flushScheduled = false;
+        const requests = this.pendingRequests;
+        this.pendingRequests = [];
+        this.flushHandler(requests).catch(error => {
+            // If batch request fails entirely, reject all pending requests
+            requests.forEach(req => req.reject(error));
+        });
+    }
+    async flushHandler(requests) {
+        if (requests.length === 0) {
+            return;
+        }
+        // Single request optimization: bypass batching
+        if (requests.length === 1) {
+            return this.singleRequest(requests[0]).then(requests[0].resolve);
+        }
+        // Multiple requests: use batch API
+        const host = await this.config.getHost();
+        const authHeader = await this.config.getAuthHeader();
+        // Build batch request payload
+        const batchRequests = requests.map(({ id, path, method, queryParams, headers, body }) => {
+            return { id, path, method, queryParams, headers, body };
+        });
+        // Send batch request
+        const batchUrl = host.replace(/\/+$/, '') + this.config.batchEndpoint;
+        const batchResponse = await this.fetcher(batchUrl, {
+            method: routing_1.METHOD.POST,
+            headers: {
+                Authorization: authHeader,
+                'Content-Type': 'application/json',
+                'X-Experience-API-Version': '1.0.0',
+            },
+            body: JSON.stringify({ requests: batchRequests }),
+        });
+        if (batchResponse.status !== 200) {
+            const errorText = await batchResponse.text();
+            // all requests will be rejected in the catch
+            throw new Error(`Batch request failed with status ${batchResponse.status}: ${errorText}`);
+        }
+        const batchResult = await batchResponse.json();
+        // Map responses back to original requests
+        const responseMap = new Map(batchResult.responses.map(r => [r.id, r]));
+        requests.forEach(req => {
+            const batchResp = responseMap.get(req.id);
+            if (!batchResp) {
+                req.reject(new Error(`No response for request ${req.id} in batch`));
+                return;
+            }
+            req.resolve({
+                status: batchResp.status,
+                headers: {
+                    get: (name) => { var _a; return ((_a = Object.entries(batchResp.headers).find(([key]) => key.toLowerCase() === name.toLowerCase())) === null || _a === void 0 ? void 0 : _a[1]) || null; },
+                },
+                json: async () => JSON.parse(batchResp.body),
+                text: async () => batchResp.body,
+            });
+        });
+    }
+}
+exports.RequestBatcher = RequestBatcher;

package/dist/cjs/services/lrsGateway/file-system.js

@@ -45,14 +45,24 @@ const assertions_1 = require("../../assertions");
 const config_1 = require("../../config");
 const errors_1 = require("../../errors");
 const guards_1 = require("../../guards");
+const hashValue_1 = require("../../misc/hashValue");
 const pageSize = 5;
 const fileSystemLrsGateway = (initializer) => (configProvider) => ({ authProvider }) => {
     const name = (0, config_1.resolveConfigValue)(configProvider[initializer.configSpace || 'fileSystem'].name);
     const filePath = name.then((fileName) => path_1.default.join(initializer.dataDir, fileName));
     const { readFile, writeFile } = (0, guards_1.ifDefined)(initializer.fs, fsModule);
     let data;
-    const load = filePath.then(path => new Promise(resolve => {
-        readFile(path, (err, readData) => {
+    let stateData;
+    /**
+     * Creates a composite key for state storage.
+     */
+    const makeStateKey = (activityId, agent, stateId, registration) => {
+        const agentName = typeof agent === 'string' ? agent : agent.account.name;
+        return (0, hashValue_1.hashValue)({ activityId, agentName, stateId, registration });
+    };
+    const stateFilePath = name.then((fileName) => path_1.default.join(initializer.dataDir, `${fileName}-state`));
+    const load = filePath.then(filePath => new Promise(resolve => {
+        readFile(filePath, (err, readData) => {
             if (err) {
                 console.error(err);
             }
@@ -70,7 +80,27 @@ const fileSystemLrsGateway = (initializer) => (configProvider) => ({ authProvide
             resolve();
         });
     }));
+    const loadState = stateFilePath.then(stateFilePath => new Promise(resolve => {
+        readFile(stateFilePath, (err, readData) => {
+            if (err) {
+                // File not existing is expected on first run
+            }
+            else {
+                try {
+                    const parsed = JSON.parse(readData.toString());
+                    if (typeof parsed === 'object' && parsed !== null && !(parsed instanceof Array)) {
+                        stateData = parsed;
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            resolve();
+        });
+    }));
     let previousSave;
+    let previousStateSave;
     const putXapiStatements = async (statements) => {
         const user = (0, assertions_1.assertDefined)(await authProvider.getUser(), new errors_1.UnauthorizedError);
         const statementsWithDefaults = statements.map(statement => ({
@@ -140,11 +170,31 @@ const fileSystemLrsGateway = (initializer) => (configProvider) => ({ authProvide
             statements: allResults.slice(0, pageSize)
         };
     };
+    const getState = async (activityId, agent, stateId, registration) => {
+        var _a;
+        await loadState;
+        const key = makeStateKey(activityId, agent, stateId, registration);
+        return (_a = stateData === null || stateData === void 0 ? void 0 : stateData[key]) !== null && _a !== void 0 ? _a : null;
+    };
+    const setState = async (activityId, agent, stateId, body, registration) => {
+        await loadState;
+        await previousStateSave;
+        const key = makeStateKey(activityId, agent, stateId, registration);
+        const path = await stateFilePath;
+        const save = previousStateSave = new Promise(resolve => {
+            stateData = stateData || {};
+            stateData[key] = body;
+            writeFile(path, JSON.stringify(stateData, null, 2), () => resolve());
+        });
+        await save;
+    };
     return {
         putXapiStatements,
         getAllXapiStatements,
         getXapiStatements,
         getMoreXapiStatements,
+        getState,
+        setState,
     };
 };
 exports.fileSystemLrsGateway = fileSystemLrsGateway;

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

@@ -10,6 +10,17 @@ type Config = {
 interface Initializer<C> {
     configSpace?: C;
     fetch: GenericFetch;
+    enableBatching?: boolean;
+}
+export interface XapiAgent {
+    objectType: 'Agent';
+    account: {
+        homePage: string;
+        name: string;
+    };
+}
+export interface StateDocument {
+    [key: string]: any;
 }
 export interface XapiStatement {
     actor: {
@@ -118,5 +129,7 @@ export declare const lrsGateway: <C extends string = "lrs">(initializer: Initial
     }) & {
         fetchUntil?: (statements: XapiStatement[]) => boolean;
     }) => Promise<XapiStatement[]>;
+    getState: (activityId: string, agent: string | XapiAgent, stateId: string, registration?: string) => Promise<StateDocument | null>;
+    setState: (activityId: string, agent: string | XapiAgent, stateId: string, body: StateDocument, registration?: string) => Promise<void>;
 };
 export {};