@openstax/ts-utils 1.21.11 → 1.23.0

package/dist/esm/services/launchParams/signer.js

@@ -0,0 +1,51 @@
+import jwt from 'jsonwebtoken';
+import ms from 'ms';
+import { JWK } from 'node-jose';
+import { once } from '../..';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+const SUPPORTED_ALGORITHMS = [
+    'RS256', 'RS384', 'RS512', 'ES256', 'ES384', 'ES512', 'HS256', 'HS384', 'HS512', 'PS256', 'PS384', 'PS512'
+];
+const assertAlg = (alg) => {
+    if ((SUPPORTED_ALGORITHMS).includes(alg)) {
+        return alg;
+    }
+    throw new Error(`"${alg}" is not a valid algorithm`);
+};
+/**
+ * Creates a class that can sign launch params
+ */
+export const createLaunchSigner = ({ configSpace }) => (configProvider) => {
+    const config = configProvider[ifDefined(configSpace, 'launch')];
+    const getAlg = once(async () => assertAlg(await resolveConfigValue(config.alg)));
+    const getExpiresIn = once(() => resolveConfigValue(config.expiresIn));
+    const getIss = once(() => resolveConfigValue(config.iss));
+    const getPrivateKey = once(() => resolveConfigValue(config.privateKey));
+    const getKeyStore = once(async () => {
+        const keystore = JWK.createKeyStore();
+        await keystore.add(await getPrivateKey(), 'pem');
+        return keystore;
+    });
+    const jwks = async () => (await getKeyStore()).toJSON(false);
+    const getExpiresInWithMax = async (maxExp) => {
+        const expiresIn = await getExpiresIn();
+        // The ms library used by jsonwebtoken can handle a value in seconds as well as a string like '1d'
+        if (!maxExp) {
+            return expiresIn;
+        }
+        // Convert both values to seconds for comparison
+        const expiresInSeconds = Math.floor(ms(expiresIn) / 1000);
+        const maxExpSeconds = maxExp - Math.floor(Date.now() / 1000);
+        return Math.min(expiresInSeconds, maxExpSeconds);
+    };
+    const sign = async (subject, maxExp) => {
+        const alg = await getAlg();
+        // expiresIn can be a number of seconds or a string like '1h' or '1d'
+        const expiresIn = await getExpiresInWithMax(maxExp);
+        const iss = await getIss();
+        const header = { alg, iss };
+        return jwt.sign({}, await getPrivateKey(), { algorithm: alg, expiresIn, header, issuer: iss, subject });
+    };
+    return { jwks, sign };
+};

package/dist/esm/services/launchParams/verifier.d.ts

@@ -0,0 +1,22 @@
+import jwt from 'jsonwebtoken';
+import type { JWK } from 'node-jose';
+import { ConfigProviderForConfig } from '../../config';
+declare type Config = {
+    trustedDomain: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetcher?: (uri: string) => Promise<{
+        keys: JWK.RawKey[];
+    }>;
+}
+/**
+ * Creates a class that can verify launch params
+ */
+export declare const createLaunchVerifier: <C extends string = "launch">({ configSpace, fetcher }: Initializer<C>) => (configProvider: { [key in C]: {
+    trustedDomain: import("../../config").ConfigValueProvider<string>;
+}; }) => {
+    verify: <T = undefined>(...[token, validator]: T extends undefined ? [string] : [string, (input: any) => T]) => Promise<T extends undefined ? jwt.JwtPayload : T>;
+};
+export declare type LaunchVerifier = ReturnType<ReturnType<typeof createLaunchVerifier>>;
+export {};

package/dist/esm/services/launchParams/verifier.js

@@ -0,0 +1,67 @@
+import jwt, { TokenExpiredError } from 'jsonwebtoken';
+import { JwksClient } from 'jwks-rsa';
+import { memoize } from '../..';
+import { resolveConfigValue } from '../../config';
+import { SessionExpiredError } from '../../errors';
+import { ifDefined } from '../../guards';
+/**
+ * Creates a class that can verify launch params
+ */
+export const createLaunchVerifier = ({ configSpace, fetcher }) => (configProvider) => {
+    const config = configProvider[ifDefined(configSpace, 'launch')];
+    const getJwksClient = memoize((jwksUri) => new JwksClient({ fetcher, jwksUri }));
+    const getJwksKey = memoize(async (jwksUri, kid) => {
+        const client = getJwksClient(jwksUri);
+        const key = await client.getSigningKey(kid);
+        return key.getPublicKey();
+    });
+    const getKey = async (header, callback) => {
+        // The JWT spec allows iss in the header as a copy of the iss claim, but we require it
+        if (!header.iss) {
+            return callback(new Error('JWT header missing iss claim'));
+        }
+        const { iss, kid } = header;
+        try {
+            const jwksUrl = new URL('/.well-known/jwks.json', iss);
+            const launchDomain = jwksUrl.hostname;
+            const trustedDomain = await resolveConfigValue(config.trustedDomain);
+            if (launchDomain !== trustedDomain && !launchDomain.endsWith(`.${trustedDomain}`)) {
+                return callback(new Error(`Untrusted launch domain: "${launchDomain}"`));
+            }
+            callback(null, await getJwksKey(jwksUrl.toString(), kid));
+        }
+        catch (error) {
+            callback(error);
+        }
+    };
+    const verify = (...[token, validator]) => new Promise((resolve, reject) => jwt.verify(token, getKey, {}, (err, payload) => {
+        if (err && err instanceof TokenExpiredError) {
+            reject(new SessionExpiredError());
+        }
+        else if (err) {
+            reject(err);
+        }
+        else if (typeof payload !== 'object') {
+            reject(new Error('received JWT token with unexpected non-JSON payload'));
+        }
+        else if (!payload.sub) {
+            reject(new Error('JWT payload missing sub claim'));
+        }
+        else {
+            // we are migrating away from json encoding all the parameters into the `sub` claim
+            // and into using separate claims for each parameter. in transition, we check if the sub
+            // is json and return it if it is. this is still a breaking change when using this
+            // utility because applications no longer need to independently json parse the result
+            // starting now.
+            const parsed = payload;
+            try {
+                const jsonSubContents = JSON.parse(payload.sub);
+                Object.assign(parsed, jsonSubContents);
+            }
+            catch (e) { } // eslint-disable-line no-empty
+            // conditional return types are annoying
+            resolve((validator ? validator(parsed) : parsed));
+        }
+    }));
+    return { verify };
+};

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

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

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +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

@@ -0,0 +1,27 @@
+/**
+ * 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 });
+    return {
+        logEvent: (level, event) => driver(level, { ...event, context: getContext() }),
+        log: (message, level = Level.Info) => driver(level, { message, context: getContext() }),
+        setContext: (obj) => { Object.assign(context, obj); },
+        createSubContext: () => createCoreLogger(driver, getContext),
+    };
+};

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

@@ -0,0 +1,5 @@
+import { User } from '../authProvider';
+import { EagerXapiStatement, UXapiStatement, XapiStatement } from '.';
+export declare const addStatementDefaultFields: (statement: (Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+    id?: string;
+}) | UXapiStatement, user: User) => EagerXapiStatement;

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

@@ -0,0 +1,14 @@
+import formatISO from 'date-fns/formatISO';
+import { v4 as uuid } from 'uuid';
+export const addStatementDefaultFields = (statement, user) => ({
+    id: uuid(),
+    actor: {
+        account: {
+            homePage: 'https://openstax.org',
+            name: user.uuid,
+        },
+        objectType: 'Agent',
+    },
+    timestamp: formatISO(new Date()),
+    ...statement,
+});

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

@@ -0,0 +1,70 @@
+import { LrsGateway, UXapiStatement } from '.';
+export declare type ActivityState = {
+    attempts: number;
+    completedAttempts: number;
+    currentAttempt?: UXapiStatement;
+    currentAttemptCompleted?: UXapiStatement;
+    currentAttemptStatements: UXapiStatement[];
+    mostRecentAttemptWithCompleted?: UXapiStatement;
+    mostRecentAttemptWithCompletedCompleted?: UXapiStatement;
+};
+export declare const matchAttempt: (statement: UXapiStatement) => boolean;
+export declare const matchAttemptCompleted: (attempt: UXapiStatement) => (statement: UXapiStatement) => boolean;
+export declare const resolveAttempts: (statements: UXapiStatement[], options?: {
+    activityIRI?: string | undefined;
+    parentActivityAttempt?: string | undefined;
+} | undefined) => UXapiStatement[];
+export declare const resolveCompletedForAttempt: (statements: UXapiStatement[], attempt: UXapiStatement, activityIRI?: string | undefined) => UXapiStatement | undefined;
+export declare const oldestStatement: (statements: UXapiStatement[]) => UXapiStatement | undefined;
+export declare const mostRecentStatement: (statements: UXapiStatement[]) => UXapiStatement | undefined;
+export declare const resolveAttemptInfo: (statements: UXapiStatement[], options?: {
+    activityIRI?: string | undefined;
+    currentAttempt?: string | undefined;
+    parentActivityAttempt?: string | undefined;
+    currentPreference?: "latest" | "oldest" | undefined;
+} | undefined) => ActivityState;
+export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGateway, activityIRI: string, options?: {
+    anyUser?: boolean | undefined;
+    attempt?: string | undefined;
+    ensureSync?: boolean | undefined;
+    user?: string | undefined;
+} | undefined) => Promise<import(".").XapiStatement[]>;
+export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
+    currentAttempt?: string | undefined;
+    parentActivityAttempt?: string | undefined;
+    ensureSync?: boolean | undefined;
+} | undefined) => Promise<ActivityState>;
+export declare const createStatement: (verb: UXapiStatement['verb'], activity: {
+    iri: string;
+    type: string;
+    name: string;
+    extensions?: {
+        [key: string]: string;
+    } | undefined;
+}, attempt: string, parentActivityIRI?: string | undefined) => Pick<UXapiStatement, 'object' | 'verb' | 'context'>;
+export declare const createAttemptStatement: (activity: {
+    iri: string;
+    type: string;
+    name: string;
+    extensions?: {
+        [key: string]: string;
+    } | undefined;
+}, parentActivity?: {
+    iri?: string | undefined;
+    attempt?: string | undefined;
+} | undefined) => Pick<UXapiStatement, 'object' | 'verb' | 'context'>;
+export declare const putAttemptStatement: (gateway: LrsGateway, activity: {
+    iri: string;
+    type: string;
+    name: string;
+    extensions?: {
+        [key: string]: string;
+    } | undefined;
+}, parentActivity?: {
+    iri?: string | undefined;
+    attempt?: string | undefined;
+} | undefined) => Promise<import(".").EagerXapiStatement>;
+export declare const createAttemptActivityStatement: (attemptStatement: UXapiStatement, verb: UXapiStatement['verb'], result?: UXapiStatement['result']) => Pick<UXapiStatement, 'object' | 'verb' | 'context' | 'result'>;
+export declare const putAttemptActivityStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, verb: UXapiStatement['verb'], result?: UXapiStatement['result']) => Promise<import(".").EagerXapiStatement>;
+export declare const createCompletedStatement: (attemptStatement: UXapiStatement, result?: UXapiStatement['result']) => Pick<UXapiStatement, 'object' | 'verb' | 'context' | 'result'>;
+export declare const putCompletedStatement: (gateway: LrsGateway, attemptStatement: UXapiStatement, result: UXapiStatement['result']) => Promise<import(".").EagerXapiStatement>;

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

@@ -0,0 +1,236 @@
+/*
+ * the structure of xapi statements for handling multiple attempts of an activity
+ * including the option of a parent activity/attempt such that a new attempt
+ * of a parent activity inherently creates a new attempt scope for sub-activities
+ * is done by convention using certain context and verb pieces of a statement.
+ * this module provides helpers for creating and retrieving statements according
+ * to this convention.
+ */
+import formatISODuration from 'date-fns/formatISODuration';
+import intervalToDuration from 'date-fns/intervalToDuration';
+import isAfter from 'date-fns/isAfter';
+import isBefore from 'date-fns/isBefore';
+import parseISO from 'date-fns/parseISO';
+var Verb;
+(function (Verb) {
+    Verb["Attempted"] = "http://adlnet.gov/expapi/verbs/attempted";
+    Verb["Completed"] = "http://adlnet.gov/expapi/verbs/completed";
+})(Verb || (Verb = {}));
+export const matchAttempt = (statement) => statement.verb.id === Verb.Attempted;
+export const matchAttemptCompleted = (attempt) => (statement) => {
+    var _a, _b;
+    return statement.verb.id === Verb.Completed
+        && statement.context !== undefined
+        && ((_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 resolveAttempts = (statements, options) => statements.filter(statement => {
+    var _a;
+    return matchAttempt(statement)
+        && (!(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, attempt, activityIRI) => statements.find(statement => matchAttemptCompleted(attempt)(statement)
+    && (!activityIRI || statement.object.id === activityIRI));
+export const oldestStatement = (statements) => statements.reduce((result, statement) => result && isBefore(parseISO('stored' in result && result.stored ? result.stored : result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
+export const mostRecentStatement = (statements) => statements.reduce((result, statement) => result && isAfter(parseISO('stored' in result && result.stored ? result.stored : result.timestamp), parseISO(statement.timestamp)) ? result : statement, statements[0]);
+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 = resolveAttempts(statements, options);
+    /* attempts that have a completed statement */
+    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)
+        : (options === null || options === void 0 ? void 0 : options.currentPreference) === 'oldest'
+            ? oldestStatement(attempts)
+            : mostRecentStatement(attempts);
+    /* all statements for the current attempt (doesn't include the attempt or completed statements) */
+    const currentAttemptStatements = currentAttempt ? statements.filter(statement => {
+        var _a;
+        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, 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, 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
+     * and instead make a new one, for instance if the implementation desires
+     * an attempt timeout feature
+     */
+    return {
+        attempts: attempts.length,
+        completedAttempts: completedAttempts.length,
+        currentAttempt,
+        currentAttemptCompleted: currentAttemptCompleted,
+        currentAttemptStatements,
+        mostRecentAttemptWithCompleted,
+        mostRecentAttemptWithCompletedCompleted,
+    };
+};
+/*
+ * 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
+ * `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 };
+    const getOptions = attempt ? { registration: attempt, ...partialOptions } : partialOptions;
+    return gateway.getAllXapiStatements({
+        activity: activityIRI,
+        related_activities: true,
+        ...getOptions,
+    });
+};
+export const loadActivityAttemptInfo = async (gateway, activityIRI, options) => {
+    const { parentActivityAttempt, ...partialOptions } = options ? options : { parentActivityAttempt: undefined };
+    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 {
+        context: {
+            ...(parentActivityIRI ? {
+                contextActivities: {
+                    parent: [
+                        {
+                            id: parentActivityIRI,
+                            objectType: 'Activity',
+                        },
+                    ],
+                },
+            } : {}),
+            registration: attempt,
+        },
+        object: {
+            definition: {
+                extensions: {
+                    ...activity.extensions
+                },
+                name: {
+                    'en-US': activity.name,
+                },
+                type: activity.type,
+            },
+            id: activity.iri,
+            objectType: 'Activity'
+        },
+        verb,
+    };
+};
+/*
+ * activity:
+ *  - iri: the IRI formatted id for this activity
+ *  - type: the IRI formatted activity type (eg: http://id.tincanapi.com/activitytype/school-assignment)
+ *  - name: the plaintext name of the activity, for reporting
+ *
+ * parentActivity:
+ *  - iri: the IRI formatted id for the parent activity
+ *  - attempt: the statement id for the parent attempt (the object of which should be the parentActivity.iri)
+ */
+export const createAttemptStatement = (activity, parentActivity) => {
+    return {
+        ...((parentActivity === null || parentActivity === void 0 ? void 0 : parentActivity.iri) || (parentActivity === null || parentActivity === void 0 ? void 0 : parentActivity.attempt) ? {
+            context: {
+                ...(parentActivity.iri ? {
+                    contextActivities: {
+                        parent: [
+                            {
+                                id: parentActivity.iri,
+                                objectType: 'Activity',
+                            },
+                        ],
+                    },
+                } : {}),
+                ...(parentActivity.attempt ? {
+                    registration: parentActivity.attempt,
+                } : {})
+            },
+        } : {}),
+        object: {
+            definition: {
+                extensions: {
+                    ...activity.extensions
+                },
+                name: {
+                    'en-US': activity.name,
+                },
+                type: activity.type,
+            },
+            id: activity.iri,
+            objectType: 'Activity'
+        },
+        verb: {
+            display: { 'en-US': 'Attempted' },
+            id: Verb.Attempted,
+        },
+    };
+};
+/* resolves with the statement id */
+export const putAttemptStatement = async (gateway, activity, parentActivity) => {
+    return (await gateway.putXapiStatements([createAttemptStatement(activity, parentActivity)]))[0];
+};
+/*
+ * creates a statement under the given attempt.
+ *
+ * `result` optional context for the attempt result (score, selected answer, etc)
+ */
+export const createAttemptActivityStatement = (attemptStatement, verb, result) => {
+    var _a;
+    return {
+        context: {
+            ...(((_a = attemptStatement.context) === null || _a === void 0 ? void 0 : _a.contextActivities) ? {
+                contextActivities: attemptStatement.context.contextActivities,
+            } : {}),
+            registration: attemptStatement.id,
+        },
+        object: attemptStatement.object,
+        verb: verb,
+        ...(result ? { result } : {}),
+    };
+};
+export const putAttemptActivityStatement = async (gateway, attemptStatement, verb, result) => {
+    return (await gateway.putXapiStatements([createAttemptActivityStatement(attemptStatement, verb, result)]))[0];
+};
+/*
+ * creates a statement that completes the given attempt.
+ *
+ * `result` optional context for the attempt result (score, selected answer, etc)
+ */
+export const createCompletedStatement = (attemptStatement, result) => {
+    var _a, _b;
+    return {
+        context: {
+            ...(((_a = attemptStatement.context) === null || _a === void 0 ? void 0 : _a.contextActivities) ? {
+                contextActivities: attemptStatement.context.contextActivities,
+            } : {}),
+            ...(((_b = attemptStatement.context) === null || _b === void 0 ? void 0 : _b.registration) ? {
+                registration: attemptStatement.context.registration,
+            } : {}),
+            statement: {
+                objectType: 'StatementRef',
+                id: attemptStatement.id,
+            }
+        },
+        object: attemptStatement.object,
+        verb: {
+            display: { 'en-US': 'Completed' },
+            id: Verb.Completed,
+        },
+        result: {
+            duration: formatISODuration(intervalToDuration({
+                start: parseISO(attemptStatement.timestamp), end: new Date()
+            })),
+            ...result,
+        }
+    };
+};
+export const putCompletedStatement = async (gateway, attemptStatement, result) => {
+    return (await gateway.putXapiStatements([createCompletedStatement(attemptStatement, result)]))[0];
+};

package/dist/esm/services/lrsGateway/file-system.d.ts

@@ -0,0 +1,17 @@
+import { ConfigProviderForConfig } from '../../config';
+import { AuthProvider } from '../authProvider';
+import { LrsGateway } from '.';
+declare type Config = {
+    name: string;
+};
+interface Initializer<C> {
+    dataDir: string;
+    fs?: Pick<typeof import('fs'), 'readFile' | 'writeFile'>;
+    configSpace?: C;
+}
+export declare const fileSystemLrsGateway: <C extends string = "fileSystem">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    name: import("../../config").ConfigValueProvider<string>;
+}; }) => ({ authProvider }: {
+    authProvider: AuthProvider;
+}) => LrsGateway;
+export {};