@openstax/ts-utils 1.40.2 → 1.41.2

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

@@ -1,40 +1,6 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lrsGateway = void 0;
-const queryString = __importStar(require("query-string"));
 const __1 = require("../..");
 const assertions_1 = require("../../assertions");
 const config_1 = require("../../config");
@@ -44,6 +10,7 @@ const guards_1 = require("../../guards");
 const helpers_1 = require("../../misc/helpers");
 const routing_1 = require("../../routing");
 const addStatementDefaultFields_1 = require("./addStatementDefaultFields");
+const batching_1 = require("./batching");
 const lrsGateway = (initializer) => (configProvider) => {
     const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'lrs')];
     const lrsHost = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.lrsHost));
@@ -55,20 +22,51 @@ const lrsGateway = (initializer) => (configProvider) => {
             wait: 1000,
             status: [502]
         });
+        // Initialize request batcher if batching is enabled
+        const enableBatching = initializer.enableBatching !== false;
+        const batcher = new batching_1.RequestBatcher(fetcher, {
+            batchEndpoint: '/api/batch',
+            getAuthHeader: lrsAuthorization,
+            getHost: lrsHost,
+        });
+        /**
+         * Makes a fetch request, optionally through the request batcher.
+         * Automatically batches concurrent requests when batching is enabled.
+         */
+        const makeFetch = async (options) => {
+            return enableBatching ? batcher.queueRequest(options) : batcher.singleRequest(options);
+        };
+        /**
+         * Formats an agent parameter into a full XapiAgent object.
+         * Accepts either a UUID string or a full XapiAgent object.
+         */
+        const formatAgent = (agent) => {
+            if (typeof agent === 'string') {
+                return {
+                    objectType: 'Agent',
+                    account: {
+                        homePage: 'https://openstax.org',
+                        name: agent,
+                    },
+                };
+            }
+            return agent;
+        };
         // Note: This method actually uses POST
         const putXapiStatements = async (statements, user) => {
             const userObj = user
                 ? { uuid: user }
                 : (0, assertions_1.assertDefined)(await authProvider.getUser(), new errors_1.UnauthorizedError);
             const statementsWithDefaults = statements.map(statement => (0, addStatementDefaultFields_1.addStatementDefaultFields)(statement, userObj));
-            const response = await fetcher((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements', {
-                body: JSON.stringify(statementsWithDefaults),
+            const response = await makeFetch({
+                path: '/data/xAPI/statements',
+                method: routing_1.METHOD.POST,
                 headers: {
                     Authorization: await lrsAuthorization(),
                     'Content-Type': 'application/json',
                     'X-Experience-API-Version': '1.0.0',
                 },
-                method: routing_1.METHOD.POST,
+                body: JSON.stringify(statementsWithDefaults),
             });
             if (![200, 201].includes(response.status)) {
                 throw new Error(`Unexpected LRS POST statements response code ${response.status} with body:
@@ -88,29 +86,51 @@ ${await response.text()}`);
             }
             return response.json();
         };
-        const getMoreXapiStatements = async (more) => fetcher((await lrsHost()).replace(/\/+$/, '') + more, {
-            headers: {
-                Authorization: await lrsAuthorization(),
-                'X-Experience-API-Version': '1.0.0',
-            },
-        }).then(formatGetXapiStatementsResponse);
-        const fetchXapiStatements = async ({ user, anyUser, ...options }) => fetcher((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
-            ...options,
-            ...(anyUser === true ? {} : {
-                agent: JSON.stringify({
+        const getMoreXapiStatements = async (more) => {
+            // 'more' is a full path with query string, so we don't use makeFetch batching here
+            const host = await lrsHost();
+            return fetcher(host.replace(/\/+$/, '') + more, {
+                headers: {
+                    Authorization: await lrsAuthorization(),
+                    'X-Experience-API-Version': '1.0.0',
+                },
+            }).then(formatGetXapiStatementsResponse);
+        };
+        const fetchXapiStatements = async ({ user, anyUser, ...options }) => {
+            const queryParams = {};
+            // Add filter params
+            if (options.verb)
+                queryParams.verb = options.verb;
+            if (options.activity)
+                queryParams.activity = options.activity;
+            if (options.registration)
+                queryParams.registration = options.registration;
+            if (options.related_activities !== undefined)
+                queryParams.related_activities = String(options.related_activities);
+            if (options.since)
+                queryParams.since = options.since;
+            if (options.until)
+                queryParams.until = options.until;
+            // Add agent unless anyUser is true
+            if (anyUser !== true) {
+                queryParams.agent = JSON.stringify({
                     account: {
                         homePage: 'https://openstax.org',
                         name: user || (0, assertions_1.assertDefined)(await authProvider.getUser(), new errors_1.UnauthorizedError()).uuid,
                     },
                     objectType: 'Agent',
-                }),
-            })
-        }), {
-            headers: {
-                Authorization: await lrsAuthorization(),
-                'X-Experience-API-Version': '1.0.0',
-            },
-        });
+                });
+            }
+            return makeFetch({
+                path: '/data/xAPI/statements',
+                method: routing_1.METHOD.GET,
+                queryParams,
+                headers: {
+                    Authorization: await lrsAuthorization(),
+                    'X-Experience-API-Version': '1.0.0',
+                },
+            });
+        };
         const getXapiStatements = async (params) => {
             const { ensureSync, ...fetchParams } = params;
             if (ensureSync) {
@@ -139,11 +159,87 @@ ${await response.text()}`);
             };
             return loadRemaining(await getXapiStatements(params));
         };
+        /**
+         * Get a single state document from the xAPI State API.
+         *
+         * @param activityId - The activity ID
+         * @param agent - The agent (UUID string or full XapiAgent object)
+         * @param stateId - The state document identifier
+         * @param registration - Optional registration UUID
+         * @returns The state document as a JSON object, or null if not found
+         */
+        const getState = async (activityId, agent, stateId, registration) => {
+            const agentObj = formatAgent(agent);
+            const queryParams = {
+                activityId,
+                agent: JSON.stringify(agentObj),
+                stateId,
+            };
+            if (registration) {
+                queryParams.registration = registration;
+            }
+            const response = await makeFetch({
+                path: '/data/xAPI/activities/state',
+                method: routing_1.METHOD.GET,
+                queryParams,
+                headers: {
+                    Authorization: await lrsAuthorization(),
+                    'X-Experience-API-Version': '1.0.0',
+                },
+            });
+            if (response.status === 404) {
+                return null;
+            }
+            if (response.status !== 200) {
+                throw new Error(`Unexpected LRS GET state response code ${response.status} with body:
+
+${await response.text()}`);
+            }
+            return response.json();
+        };
+        /**
+         * Create or update a state document in the xAPI State API.
+         *
+         * @param activityId - The activity ID
+         * @param agent - The agent (UUID string or full XapiAgent object)
+         * @param stateId - The state document identifier
+         * @param body - The state document content (JSON object)
+         * @param registration - Optional registration UUID
+         */
+        const setState = async (activityId, agent, stateId, body, registration) => {
+            const agentObj = formatAgent(agent);
+            const queryParams = {
+                activityId,
+                agent: JSON.stringify(agentObj),
+                stateId,
+            };
+            if (registration) {
+                queryParams.registration = registration;
+            }
+            const response = await makeFetch({
+                path: '/data/xAPI/activities/state',
+                method: routing_1.METHOD.PUT,
+                queryParams,
+                headers: {
+                    Authorization: await lrsAuthorization(),
+                    'Content-Type': 'application/json',
+                    'X-Experience-API-Version': '1.0.0',
+                },
+                body: JSON.stringify(body),
+            });
+            if (response.status !== 204) {
+                throw new Error(`Unexpected LRS PUT state response code ${response.status} with body:
+
+${await response.text()}`);
+            }
+        };
         return {
             putXapiStatements,
             getXapiStatements,
             getMoreXapiStatements,
             getAllXapiStatements,
+            getState,
+            setState,
         };
     };
 };