@openstax/ts-utils 1.2.9 → 1.3.1

package/dist/esm/routing/index.js

@@ -3,46 +3,63 @@ import queryString from 'query-string';
 import { mapFind, memoize } from '../misc/helpers';
 import { createProfile } from '../profile';
 import { createConsoleLogger } from '../services/logger/console';
-/*
- * route definition helper. the only required params of the route are the name, path, and handler. other params
- * can be added to the type and then later used in the routeMatcher. when defining the `createRoute` method, only
- * the request input format is defined, the result format is derived from the routes.
+/**
+ * Makes a createRoute function that can be used to create routes (this is a factory factory). The
+ * `makeCreateRoute` function is typically called once in the backend and once in the frontend to
+ * set the types for the resulting `createRoute` function -- that latter function is called once
+ * per route. E.g. for the backend, the call could look like:
  *
- * eg:
- *   export const createRoute = makeCreateRoute<AppServices, ApiRouteRequest, {
- *     method: METHOD;
- *   }>();
+ * ```
+ * export const createRoute = makeCreateRoute<AppServices, ApiRouteRequest, {
+ *   method: METHOD;
+ * }>();
+ * ```
  *
- * eg when defining requestServiceProvider in line, the types have a hard time, it helps to put in another argument:
- *   export const exampleRoute = createRoute({name: 'exampleRoute', method: METHOD.GET, path: '/api/example/:key',
- *     requestServiceProvider: requestServiceProvider({
- *       cookieAuthMiddleware,
- *       documentStoreMiddleware,
- *     }},
- *     async(params: {key: string}, services) => {
- *       const result = await services.myDocumentStore.getItem(params.key);
+ * Notes:
+ * * The `{method: METHOD}` defines the `Ex` extension type; here, the `method` property is only
+ *   relevant to backend routes.
+ * * when defining the `createRoute` method, only the request input format is defined, the output
+ *   format is derived from the routes.
+ *
+ * When calling the resulting `createRoute` function, the only required params of the route are the
+ * name, path, and handler. Other params can be added to the type and then later used in the
+ * routeMatcher.
  *
- *       if (!result) {
- *         throw new NotFoundError('requested item not found');
- *       }
+ * eg when defining requestServiceProvider in line, the types have a hard time, it helps to put in another argument:
+ * ```
+ * export const exampleRoute = createRoute({
+ *   name: 'exampleRoute', method: METHOD.GET, path: '/api/example/:key',
+ *   requestServiceProvider: composeServiceMiddleware({
+ *     cookieAuthMiddleware,
+ *     documentStoreMiddleware,
+ *   }},
+ *   async(params: {key: string}, services) => {
+ *     const result = await services.myDocumentStore.getItem(params.key);
  *
- *       return apiJsonResponse(200, result);
+ *     if (!result) {
+ *       throw new NotFoundError('requested item not found');
  *     }
- *   );
  *
+ *     return apiJsonResponse(200, result);
+ *   }
+ * );
+ * ```
  * eg when using a pre-existing provider variable the types work better:
- *   export const exampleRoute = createRoute({name: 'exampleRoute', method: METHOD.GET, path: '/api/example/:key',
- *     requestServiceProvider,
- *     handler: async(params: {key: string}, services) => {
- *       const result = await services.myDocumentStore.getItem(params.key);
- *
- *       if (!result) {
- *         throw new NotFoundError('requested item not found');
- *       }
+ * ```
+ * export const exampleRoute = createRoute({
+ *   name: 'exampleRoute', method: METHOD.GET, path: '/api/example/:key',
+ *   requestServiceProvider,
+ *   handler: async(params: {key: string}, services) => {
+ *     const result = await services.myDocumentStore.getItem(params.key);
  *
- *       return apiJsonResponse(200, result);
+ *     if (!result) {
+ *       throw new NotFoundError('requested item not found');
  *     }
- *   });
+ *
+ *     return apiJsonResponse(200, result);
+ *   }
+ * });
+ * ```
  */
 export const makeCreateRoute = () => (...args) => {
     return (args.length === 1
@@ -50,12 +67,37 @@ export const makeCreateRoute = () => (...args) => {
         : { ...args[0], handler: args[1] });
 };
 /* begin reverse routing utils */
+/**
+ * Makes a renderRouteUrl function that can be used to render route paths (this is a factory
+ * factory). The returned function takes a `route`, `params`, and `query` and returns a string
+ * with the params and query substituted into the route path.
+ *
+ * this function is initialized using the Ru type which indicates the specific routes wired into
+ * the application, which means that if you try to build a url with a route which is not wired
+ * into the router you will get a type error. this is a feature to prevent referencing routes that
+ * don't exist or aren't handling requests properly.
+ *
+ * if you are making a helper function or need to render a route outside your application, you
+ * can use the `renderAnyRouteUrl` function
+ */
 export const makeRenderRouteUrl = () => (route, params, query = {}) => {
     const getPathForParams = pathToRegexp.compile(route.path, { encode: encodeURIComponent });
     const search = queryString.stringify(query);
     const path = getPathForParams(params) + (search ? `?${search}` : '');
     return path;
 };
+/**
+ * A pre-made result from `makeRenderRouteUrl`, this function interpolates parameter and query
+ * arguments into a route path.
+ *
+ * prefer using `renderRouteUrl` initialized with your applications route union
+ * when possible to help catch improperly initialized routes.
+ *
+ * @param route the route that has a `path` to be interpolated
+ * @param params the parameters to interpolate into the route path
+ * @param query the query parameters to add to the route path
+ * @returns the interpolated route path
+ */
 export const renderAnyRouteUrl = makeRenderRouteUrl();
 const bindRoute = (services, appBinder, pathExtractor, matcher) => (route) => {
     const getParamsFromPath = pathToRegexp.match(route.path, { decode: decodeURIComponent });
@@ -68,24 +110,35 @@ const bindRoute = (services, appBinder, pathExtractor, matcher) => (route) => {
         }
     };
 };
-/*
- * here among other things we're specifying a generic response format that the response and error handling middleware can use,
- * if any routes have responses that don't adhere to this it'll complain about it.
+/**
+ * A factory factory for creating request responders (functions that take a request and return a
+ * response -- these functions let us implement Lambda `handler` functions).
  *
- * eg:
- *   export const getRequestResponder = makeGetRequestResponder<AppServices, TRoutes, ApiRouteRequest, Promise<ApiRouteResponse>>()({
+ * Use it in two steps. First, call it with the general business logic that defines routes, logs,
+ * errors, etc:
+ * ```
+ * const getRequestResponder = makeGetRequestResponder<
+ *    AppServices, TRoutes, ApiRouteRequest, Promise<ApiRouteResponse>
+ *   >()  // this empty invocation helps typescript mix defined and inferred types
+ *   ({
  *     routes: apiRoutes, // the route definitions
- *     pathExtractor, // how to get the path out of the request format
- *     routeMatcher, // logic for matching route (if there is any in addition to the path matching)
- *     errorHandler, // any special error handling
+ *     pathExtractor,     // how to get the path out of the request format
+ *     routeMatcher,      // logic for matching route (beyond path matching, optional)
+ *     errorHandler,      // any special error handling
  *   });
+ * ```
+ * Note here that among other things we're specifying a generic response format that the response
+ * and error handling middleware can use, if any routes have responses that don't adhere to this
+ * it'll complain about it.
  *
- * eg an lambda entrypoint:
- *   export const handler: (request: APIGatewayProxyEventV2) => Promise<ApiRouteResponse> =
- *     getRequestResponder(
- *       lambdaServices, // the AppServices for this entrypoint
- *       lambdaMiddleware // environment specific response middleware (like cors)
- *     );
+ * Next, we use the `getRequestResponder` to create a responder for a specific lambda entrypoint:
+ * ```
+ * export const handler: (request: APIGatewayProxyEventV2): Promise<ApiRouteResponse> =>
+ *   getRequestResponder(
+ *     lambdaServices,  // the AppServices for this entrypoint
+ *     lambdaMiddleware // environment specific response middleware (like cors)
+ *   );
+ * ```
  */
 export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatcher, errorHandler, logExtractor }) => (services, responseMiddleware) => {
     const appBinderImpl = (app, middleware) => middleware(app, appBinder);
@@ -136,9 +189,38 @@ export const makeGetRequestResponder = () => ({ routes, pathExtractor, routeMatc
         return undefined;
     };
 };
+/**
+ * Returns a JSON response. Handles serializing the data to JSON and setting the content-type header.
+ * @param statusCode e.g. 201
+ * @param data the object to be serialized to JSON
+ * @param headers HTTP headers
+ * @example
+ * return apiJsonResponse(
+ *   200, {
+ *     message: "hello, world!",
+ *     foo: "bar",
+ *   },
+ *   { 'X-Frame-Options': 'DENY' }
+ * );
+ */
 export const apiJsonResponse = (statusCode, data, headers) => ({ statusCode, data, body: JSON.stringify(data), headers: { ...headers, 'content-type': 'application/json' } });
+/**
+ * Returns a plain text response. Handles setting the content-type header.
+ * @param statusCode e.g. 201
+ * @param data some string
+ * @param headers HTTP headers
+ * @example return apiTextResponse(200, 'some text')
+ */
 export const apiTextResponse = (statusCode, data, headers) => ({ statusCode, data, body: data, headers: { ...headers, 'content-type': 'text/plain' } });
+/**
+ * Returns an HTML response. Handles setting the content-type header.
+ * @param statusCode e.g. 201
+ * @param data some string
+ * @param headers HTTP headers
+ * @example return apiHtmlResponse(200, '<b>some text</b>')
+ */
 export const apiHtmlResponse = (statusCode, data, headers) => ({ statusCode, data, body: data, headers: { ...headers, 'content-type': 'text/html' } });
+/** HTTP method enum */
 export var METHOD;
 (function (METHOD) {
     METHOD["GET"] = "GET";

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

@@ -41,6 +41,7 @@ declare type MapRoutesToConfig<Ru> = [Ru] extends [AnyRoute<Ru>] ? {
         method: string;
     };
 } : never;
+/** Pulls the content out of a response based on the content type */
 export declare const loadResponse: (response: Response) => () => Promise<any>;
 interface MakeApiGateway<F> {
     <Ru>(config: ConfigProviderForConfig<{

package/dist/esm/services/apiGateway/index.js

@@ -3,6 +3,7 @@ import queryString from 'query-string';
 import { merge } from '../..';
 import { resolveConfigValue } from '../../config';
 import { SessionExpiredError, UnauthorizedError } from '../../errors';
+/** Pulls the content out of a response based on the content type */
 export const loadResponse = (response) => () => {
     const [contentType] = (response.headers.get('content-type') || '').split(';');
     switch (contentType) {
@@ -15,6 +16,7 @@ export const loadResponse = (response) => () => {
     }
 };
 const makeRouteClient = (initializer, config, route, authProvider) => {
+    /* TODO this duplicates code with makeRenderRouteUrl, reuse that */
     const renderUrl = async ({ params, query }) => {
         const apiBase = await resolveConfigValue(config.apiBase);
         const getPathForParams = pathToRegexp.compile(route.path, { encode: encodeURIComponent });

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

@@ -12,13 +12,14 @@ export interface TokenUser {
     is_administrator: boolean;
 }
 export interface ApiUser extends TokenUser {
-    is_not_gdpr_location: boolean;
     contact_infos: Array<{
         type: string;
         value: string;
         is_verified: boolean;
         is_guessed_preferred: boolean;
     }>;
+    external_ids: string[];
+    is_not_gdpr_location: boolean;
     signed_contract_names: string[];
 }
 export declare type User = TokenUser | ApiUser;

package/dist/esm/services/authProvider/utils/decryptAndVerify.d.ts

@@ -1,2 +1,11 @@
 import { User } from '..';
+/**
+ * Decrypts and verifies a SSO cookie.
+ *
+ * @param token the encrypted token
+ * @param encryptionPrivateKey the private key used to encrypt the token
+ * @param signaturePublicKey the public key used to verify the decrypted token
+ * @throws SessionExpiredError if the token is expired
+ * @returns User (success) or undefined (failure)
+ */
 export declare const decryptAndVerify: (token: string, encryptionPrivateKey: string, signaturePublicKey: string) => User | undefined;

package/dist/esm/services/authProvider/utils/decryptAndVerify.js

@@ -18,6 +18,15 @@ const decrypt = (input, key) => {
     ]);
     return result.toString('utf-8');
 };
+/**
+ * Decrypts and verifies a SSO cookie.
+ *
+ * @param token the encrypted token
+ * @param encryptionPrivateKey the private key used to encrypt the token
+ * @param signaturePublicKey the public key used to verify the decrypted token
+ * @throws SessionExpiredError if the token is expired
+ * @returns User (success) or undefined (failure)
+ */
 export const decryptAndVerify = (token, encryptionPrivateKey, signaturePublicKey) => {
     try {
         // Decrypt SSO cookie

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

@@ -1 +1,4 @@
+/**
+ * Creates a logger that logs to the console.
+ */
 export declare const createConsoleLogger: () => import(".").Logger;

package/dist/esm/services/logger/console.js

@@ -1,4 +1,7 @@
 import { createCoreLogger } from '.';
+/**
+ * Creates a logger that logs to the console.
+ */
 export const createConsoleLogger = () => createCoreLogger((level, event) => console[level](JSON.stringify({
     eventType: level.toUpperCase(),
     ...event,

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

@@ -1,14 +1,39 @@
 import { JsonCompatibleStruct } from '../../routing';
+/**
+ * The log level
+ */
 export declare enum Level {
     Info = "info",
     Warn = "warn",
     Error = "error"
 }
+/**
+ * A function that logs an event at a certain level.
+ *
+ * @param level - log level
+ * @param event - event to log
+ */
 export declare type LogEvent = (level: Level, event: JsonCompatibleStruct) => void;
+/**
+ * A logger that can be used to log events.
+ *
+ * @property setContext - sets a context object to be included in all future logged events
+ * @property logEvent - logs an arbitrary event at a certain level, without context
+ * @property log - logs a message and the context at a certain level
+ * @property createSubContext - creates a new logger that inherits the context of this logger
+ */
 export interface Logger {
     setContext: (obj: JsonCompatibleStruct) => void;
     logEvent: LogEvent;
     log: (message: string, level?: Level) => void;
     createSubContext: () => Logger;
 }
+/**
+ * Creates a logger that logs events using the given driver and context provider.
+ *
+ * @param driver the driver that logs events
+ * @param getParentContext a provider that returns the context to use for this 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;

package/dist/esm/services/logger/index.js

@@ -1,9 +1,20 @@
+/**
+ * The log level
+ */
 export var Level;
 (function (Level) {
     Level["Info"] = "info";
     Level["Warn"] = "warn";
     Level["Error"] = "error";
 })(Level || (Level = {}));
+/**
+ * Creates a logger that logs events using the given driver and context provider.
+ *
+ * @param driver the driver that logs events
+ * @param getParentContext a provider that returns the context to use for this logger
+ *   (the context is returned when messages are logged with the logger)
+ * @returns a Logger
+ */
 export const createCoreLogger = (driver, getParentContext) => {
     const context = {};
     const getContext = () => ({ ...getParentContext === null || getParentContext === void 0 ? void 0 : getParentContext(), ...context });

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

@@ -10,11 +10,15 @@ export declare type ActivityState = {
 };
 export declare const matchAttempt: (statement: XapiStatement) => boolean;
 export declare const matchAttemptCompleted: (attempt: XapiStatement) => (statement: XapiStatement) => boolean;
-export declare const resolveActivityAttempts: (statements: XapiStatement[], activityIRI: string, parentActivityAttempt?: string | undefined) => XapiStatement[];
-export declare const resolveCompletedForAttempt: (statements: XapiStatement[], activityIRI: string, attempt: XapiStatement) => XapiStatement | undefined;
+export declare const resolveAttempts: (statements: XapiStatement[], options?: {
+    activityIRI?: string | undefined;
+    parentActivityAttempt?: string | undefined;
+} | undefined) => XapiStatement[];
+export declare const resolveCompletedForAttempt: (statements: XapiStatement[], attempt: XapiStatement, activityIRI?: string | undefined) => XapiStatement | undefined;
 export declare const oldestStatement: (statements: XapiStatement[]) => XapiStatement | undefined;
 export declare const mostRecentStatement: (statements: XapiStatement[]) => XapiStatement | undefined;
-export declare const resolveActivityAttemptInfo: (statements: XapiStatement[], activityIRI: string, options?: {
+export declare const resolveAttemptInfo: (statements: XapiStatement[], options?: {
+    activityIRI?: string | undefined;
     currentAttempt?: string | undefined;
     parentActivityAttempt?: string | undefined;
     currentPreference?: "latest" | "oldest" | undefined;
@@ -23,13 +27,6 @@ export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGat
     attempt?: string | undefined;
     ensureSync?: boolean | undefined;
 } | undefined) => Promise<XapiStatement[]>;
-export declare const loadStatementsForAttempt: (gateway: LrsGateway, attempt: string, options?: {
-    ensureSync?: boolean | undefined;
-} | undefined) => Promise<XapiStatement[]>;
-export declare const loadStatementsForActivity: (gateway: LrsGateway, activityIRI: string, options?: {
-    attempt?: string | undefined;
-    ensureSync?: boolean | undefined;
-} | undefined) => Promise<XapiStatement[]>;
 export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
     currentAttempt?: string | undefined;
     parentActivityAttempt?: string | undefined;

package/dist/esm/services/lrsGateway/attempt-utils.js

@@ -24,21 +24,21 @@ export const matchAttemptCompleted = (attempt) => (statement) => {
         && ((_a = statement.context.statement) === null || _a === void 0 ? void 0 : _a.id) === attempt.id
         && statement.context.registration === ((_b = attempt.context) === null || _b === void 0 ? void 0 : _b.registration);
 };
-export const resolveActivityAttempts = (statements, activityIRI, parentActivityAttempt) => statements.filter(statement => {
+export const resolveAttempts = (statements, options) => statements.filter(statement => {
     var _a;
     return matchAttempt(statement)
-        && statement.object.id === activityIRI
-        && (!parentActivityAttempt || ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === parentActivityAttempt);
+        && (!(options === null || options === void 0 ? void 0 : options.activityIRI) || statement.object.id === options.activityIRI)
+        && (!(options === null || options === void 0 ? void 0 : options.parentActivityAttempt) || ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === options.parentActivityAttempt);
 });
-export const resolveCompletedForAttempt = (statements, activityIRI, attempt) => statements.find(statement => matchAttemptCompleted(attempt)(statement)
-    && statement.object.id === activityIRI);
+export const resolveCompletedForAttempt = (statements, attempt, activityIRI) => statements.find(statement => matchAttemptCompleted(attempt)(statement)
+    && (!activityIRI || statement.object.id === activityIRI));
 export const oldestStatement = (statements) => statements.reduce((result, statement) => result && isBefore(parseISO(result.stored || result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
 export const mostRecentStatement = (statements) => statements.reduce((result, statement) => result && isAfter(parseISO(result.stored || result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
-export const resolveActivityAttemptInfo = (statements, activityIRI, options) => {
+export const resolveAttemptInfo = (statements, options) => {
     // TODO optimize. i'm 100% that this could all be done in one iteration but i'm not messing around with that for now.
-    const attempts = resolveActivityAttempts(statements, activityIRI, options === null || options === void 0 ? void 0 : options.parentActivityAttempt);
+    const attempts = resolveAttempts(statements, options);
     /* attempts that have a completed statement */
-    const completedAttempts = attempts.filter(attempt => !!resolveCompletedForAttempt(statements, activityIRI, attempt));
+    const completedAttempts = attempts.filter(attempt => !!resolveCompletedForAttempt(statements, attempt, options === null || options === void 0 ? void 0 : options.activityIRI));
     /* the last attempt sorted by timestamp */
     const currentAttempt = (options === null || options === void 0 ? void 0 : options.currentAttempt)
         ? attempts.find(attempt => attempt.id === options.currentAttempt)
@@ -48,13 +48,13 @@ export const resolveActivityAttemptInfo = (statements, activityIRI, options) =>
     /* all statements for the current attempt (doesn't include the attempt or completed statements) */
     const currentAttemptStatements = currentAttempt ? statements.filter(statement => {
         var _a;
-        return statement.object.id === activityIRI
+        return (!(options === null || options === void 0 ? void 0 : options.activityIRI) || statement.object.id === options.activityIRI)
             && ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === currentAttempt.id;
     }) : [];
-    const currentAttemptCompleted = currentAttempt && resolveCompletedForAttempt(statements, activityIRI, currentAttempt);
+    const currentAttemptCompleted = currentAttempt && resolveCompletedForAttempt(statements, currentAttempt, options === null || options === void 0 ? void 0 : options.activityIRI);
     const mostRecentAttemptWithCompleted = completedAttempts.reduce((current, attempt) => current && isAfter(parseISO(current.timestamp), parseISO(attempt.timestamp)) ? current : attempt, completedAttempts[0]);
     const mostRecentAttemptWithCompletedCompleted = mostRecentAttemptWithCompleted
-        && resolveCompletedForAttempt(statements, activityIRI, mostRecentAttemptWithCompleted);
+        && resolveCompletedForAttempt(statements, mostRecentAttemptWithCompleted, options === null || options === void 0 ? void 0 : options.activityIRI);
     /*
      * the structure allows for the possibility of multiple incomplete attempts.
      * the implementation can choose at its discretion to ignore the currentAttempt
@@ -75,8 +75,9 @@ export const resolveActivityAttemptInfo = (statements, activityIRI, options) =>
  * loads all statements (for this actor) that have the given activityIRI as the object.id or the context.contextActivities.parent.id
  *
  * note: if you filter on attempt you're only gonna get the `Attempted` statements from the child activities, subsequent child activity
- * statements would then have to be fetched using `loadStatementsForActivity(gateway, childActivityIRI, childAttemptStatementID)`. this
- * is because child activities could have multiple attempts under one attempt on the parent activity.
+ * statements would then have to be fetched using
+ * `gateway.getAllXapiStatements({ activity: childActivityIRI, registration: childAttemptStatementID })`.
+ * this is because child activities could have multiple attempts under one attempt on the parent activity.
  */
 export const loadStatementsForActivityAndFirstChildren = (gateway, activityIRI, options) => {
     const { attempt, ...partialOptions } = options ? options : { attempt: undefined };
@@ -87,30 +88,10 @@ export const loadStatementsForActivityAndFirstChildren = (gateway, activityIRI,
         ...getOptions,
     });
 };
-/*
- * loads all statements (for this actor) that have the given parent attempt (registration)
- */
-export const loadStatementsForAttempt = (gateway, attempt, options) => {
-    return gateway.getAllXapiStatements({
-        registration: attempt,
-        ...(options ? options : {})
-    });
-};
-/*
- * loads all statements (for this actor) that have the given activityIRI as the object.id
- */
-export const loadStatementsForActivity = (gateway, activityIRI, options) => {
-    const { attempt, ...partialOptions } = options ? options : { attempt: undefined };
-    const getOptions = attempt ? { registration: attempt, ...partialOptions } : partialOptions;
-    return gateway.getAllXapiStatements({
-        activity: activityIRI,
-        ...getOptions,
-    });
-};
 export const loadActivityAttemptInfo = async (gateway, activityIRI, options) => {
     const { parentActivityAttempt, ...partialOptions } = options ? options : { parentActivityAttempt: undefined };
-    const loadOptions = parentActivityAttempt ? { attempt: parentActivityAttempt } : partialOptions;
-    return resolveActivityAttemptInfo(await loadStatementsForActivity(gateway, activityIRI, loadOptions), activityIRI, options);
+    const loadOptions = parentActivityAttempt ? { ...partialOptions, registration: parentActivityAttempt } : partialOptions;
+    return resolveAttemptInfo(await gateway.getAllXapiStatements({ ...loadOptions, activity: activityIRI }), { ...options, activityIRI });
 };
 export const createStatement = (verb, activity, attempt, parentActivityIRI) => {
     return {

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

@@ -57,19 +57,33 @@ export const fileSystemLrsGateway = (initializer) => (configProvider) => (authPr
         await save;
         return statementsWithDefaults;
     };
-    const getAllXapiStatements = async ({ user, anyUser, ...options }) => {
+    const getAllXapiStatements = async ({ user, anyUser, fetchUntil, ...options }) => {
         const authUser = await authProvider.getUser();
         await load;
-        return (data || []).filter(statement => {
+        let filteredData = (data || []).filter(statement => {
             var _a, _b, _c, _d;
+            const statementDate = new Date(statement.timestamp);
+            const sinceDate = options.since ? new Date(options.since) : null;
+            const untilDate = options.until ? new Date(options.until) : null;
             return (anyUser === true || statement.actor.account.name === (user || assertDefined(authUser, new UnauthorizedError()).uuid))
                 && (!options.verb || statement.verb.id === options.verb)
                 && (!options.registration || ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === options.registration)
                 && (!options.activity || (options.related_activities
                     ? ((statement.object.id === options.activity && statement.object.objectType === 'Activity')
                         || (!!((_d = (_c = (_b = statement.context) === null || _b === void 0 ? void 0 : _b.contextActivities) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.find(parent => parent.id === options.activity && parent.objectType === 'Activity'))))
-                    : (statement.object.id === options.activity && statement.object.objectType === 'Activity')));
+                    : (statement.object.id === options.activity && statement.object.objectType === 'Activity')))
+                && (!sinceDate || statementDate >= sinceDate)
+                && (!untilDate || statementDate <= untilDate);
         });
+        if (fetchUntil) {
+            for (let i = 0; i < filteredData.length; i += pageSize) {
+                if (fetchUntil(filteredData.slice(0, i + pageSize))) {
+                    filteredData = filteredData.slice(0, i + pageSize);
+                    break;
+                }
+            }
+        }
+        return filteredData;
     };
     const getMoreXapiStatements = async (more) => {
         const { args, offset } = JSON.parse(more);

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

@@ -90,6 +90,8 @@ export declare const lrsGateway: <C extends string = "lrs">(initializer: Initial
         related_activities?: boolean | undefined;
         user?: string | undefined;
         anyUser?: boolean | undefined;
+        since?: string | undefined;
+        until?: string | undefined;
     } & {
         ensureSync?: boolean | undefined;
     }) => Promise<{
@@ -100,15 +102,19 @@ export declare const lrsGateway: <C extends string = "lrs">(initializer: Initial
         more: string;
         statements: XapiStatement[];
     }>;
-    getAllXapiStatements: (params: {
+    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;
+    } & {
+        fetchUntil?: ((statements: XapiStatement[]) => boolean) | undefined;
     }) => Promise<XapiStatement[]>;
 };
 export {};

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

@@ -94,9 +94,9 @@ ${await response.text()}`);
                 return formatGetXapiStatementsResponse(fetchXapiStatements(fetchParams));
             }
         };
-        const getAllXapiStatements = async (params) => {
+        const getAllXapiStatements = async ({ fetchUntil, ...params }) => {
             const loadRemaining = async (result) => {
-                if (!result.more) {
+                if (!result.more || (fetchUntil && fetchUntil(result.statements))) {
                     return result.statements;
                 }
                 const { more, statements } = await getMoreXapiStatements(result.more);