@openstax/ts-utils 1.0.0

package/dist/services/exercisesGateway/index.d.ts

@@ -0,0 +1,80 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { METHOD } from '../../routing';
+export declare type Config = {
+    defaultCorrectness?: string;
+    exercisesHost: string;
+    exercisesAuthToken: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export declare type Answer = {
+    id: number;
+    content_html: string;
+    correctness?: string;
+    feedback_html?: string;
+};
+export declare type Solution = {
+    images: any[];
+    solution_type: string;
+    content_html: string;
+};
+export declare type Question = {
+    id: number;
+    is_answer_order_important: boolean;
+    stimulus_html: string;
+    stem_html: string;
+    answers: Answer[];
+    hints: string[];
+    formats: string[];
+    combo_choices: any[];
+    collaborator_solutions?: Solution[];
+    community_solutions?: Solution[];
+};
+export declare type Exercise = {
+    images: any[];
+    tags: string[];
+    uuid: string;
+    group_uuid: string;
+    number: number;
+    version: number;
+    uid: string;
+    published_at: string;
+    solutions_are_public: boolean;
+    authors: any[];
+    copyright_holders: any[];
+    derived_from: any[];
+    is_vocab: boolean;
+    questions: Question[];
+    delegations: any[];
+    versions: number[];
+    stimulus_html: string;
+};
+export declare type ExercisesSearchResults = {
+    total_count: number;
+    items: Exercise[];
+};
+export declare type ExercisesSearchResultsWithDigest = ExercisesSearchResults & {
+    digest: string;
+};
+export declare const exercisesGateway: <C extends string = "exercises">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    defaultCorrectness?: import("../../config").ConfigValueProvider<string> | undefined;
+    exercisesHost: import("../../config").ConfigValueProvider<string>;
+    exercisesAuthToken: import("../../config").ConfigValueProvider<string>;
+}; }) => {
+    searchDigest: (query: string, page?: number, per_page?: number) => Promise<string>;
+    get: (uuid: string) => Promise<Exercise | undefined>;
+    request: (method: METHOD, path: string, query?: object | undefined) => Promise<{
+        status: number;
+        headers: {
+            get: (name: string) => string | null;
+        };
+        json: () => Promise<any>;
+        text: () => Promise<string>;
+    }>;
+    search: (query: string, page?: number, per_page?: number) => Promise<ExercisesSearchResultsWithDigest>;
+};
+export declare type ExercisesGateway = ReturnType<ReturnType<typeof exercisesGateway>>;
+export {};

package/dist/services/exercisesGateway/index.js

@@ -0,0 +1,94 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exercisesGateway = void 0;
+const queryString = __importStar(require("query-string"));
+const assertions_1 = require("../../assertions");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const routing_1 = require("../../routing");
+const exercisesGateway = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'exercises')];
+    const exercisesHost = (0, config_1.resolveConfigValue)(config.exercisesHost);
+    const exercisesAuthToken = (0, config_1.resolveConfigValue)(config.exercisesAuthToken);
+    const defaultCorrectness = (0, config_1.resolveConfigValue)(config.defaultCorrectness || '');
+    const doDefaultCorrectness = async (exercise) => {
+        if (await defaultCorrectness !== 'true') {
+            return exercise;
+        }
+        for (const question of exercise.questions) {
+            const existingCorrect = question.answers.find(answer => answer.correctness !== undefined);
+            if (question.answers.length < 1 || existingCorrect) {
+                continue;
+            }
+            const defaultCorrectIndex = question.id % question.answers.length;
+            const defaultCorrect = question.answers[defaultCorrectIndex];
+            const defaultHint = `<em>random default: the correct answer is ${defaultCorrect.id}: ${defaultCorrect.content_html.slice(0, 20)}</em>`;
+            question.stem_html += `\n<br>${defaultHint}`;
+            question.collaborator_solutions = [
+                { solution_type: 'detailed', images: [], content_html: defaultHint }
+            ];
+            for (const [index, answer] of question.answers.entries()) {
+                answer.correctness = defaultCorrectIndex === index ? '1.0' : '0.0';
+                answer.feedback_html = defaultCorrectIndex === index ? 'This is the good one!' : defaultHint;
+            }
+        }
+        return exercise;
+    };
+    const request = async (method, path, query = undefined) => {
+        const host = (await exercisesHost).replace(/\/+$/, '');
+        const baseUrl = `${host}/api/${path}`;
+        const url = query ? `${baseUrl}?${queryString.stringify(query)}` : baseUrl;
+        return initializer.fetch(url, {
+            headers: {
+                Authorization: `Bearer ${await exercisesAuthToken}`,
+            },
+            method,
+        });
+    };
+    const searchDigest = async (query, page = 1, per_page = 100) => {
+        const response = await request(routing_1.METHOD.HEAD, 'exercises', { query, page, per_page });
+        return (0, assertions_1.assertString)(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint HEAD did not return an X-Digest header');
+    };
+    const search = async (query, page = 1, per_page = 100) => {
+        const response = await request(routing_1.METHOD.GET, 'exercises', { query, page, per_page });
+        const digest = (0, assertions_1.assertString)(response.headers.get('X-Digest'), 'OpenStax Exercises search endpoint GET did not return an X-Digest header');
+        const { items, total_count } = await response.json();
+        return { digest, items: await Promise.all(items.map(doDefaultCorrectness)), total_count };
+    };
+    const get = async (uuid) => {
+        const response = await request(routing_1.METHOD.GET, `exercises/${uuid}`);
+        return response.status === 404
+            ? undefined
+            : response.json().then(doDefaultCorrectness);
+    };
+    return {
+        searchDigest,
+        get,
+        request,
+        search,
+    };
+};
+exports.exercisesGateway = exercisesGateway;

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

@@ -0,0 +1,60 @@
+import { LrsGateway, XapiStatement } from '.';
+export declare type ActivityState = {
+    attempts: number;
+    completedAttempts: number;
+    currentAttempt?: XapiStatement;
+    currentAttemptCompleted?: XapiStatement;
+    currentAttemptStatements: XapiStatement[];
+    mostRecentAttemptWithCompleted?: XapiStatement;
+    mostRecentAttemptWithCompletedCompleted?: XapiStatement;
+};
+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 mostRecentStatement: (statements: XapiStatement[]) => XapiStatement | undefined;
+export declare const resolveActivityAttemptInfo: (statements: XapiStatement[], activityIRI: string, options?: {
+    currentAttempt?: string | undefined;
+    parentActivityAttempt?: string | undefined;
+} | undefined) => ActivityState;
+export declare const loadStatementsForActivityAndFirstChildren: (gateway: LrsGateway, activityIRI: string, attempt?: string | undefined) => Promise<XapiStatement[]>;
+export declare const loadStatementsForAttempt: (gateway: LrsGateway, attempt: string) => Promise<XapiStatement[]>;
+export declare const loadStatementsForActivity: (gateway: LrsGateway, activityIRI: string, attempt?: string | undefined) => Promise<XapiStatement[]>;
+export declare const loadActivityAttemptInfo: (gateway: LrsGateway, activityIRI: string, options?: {
+    currentAttempt?: string | undefined;
+    parentActivityAttempt?: string | undefined;
+} | undefined) => Promise<ActivityState>;
+export declare const createStatement: (verb: XapiStatement['verb'], activity: {
+    iri: string;
+    type: string;
+    name: string;
+    extensions?: {
+        [key: string]: string;
+    } | undefined;
+}, attempt: string, parentActivityIRI?: string | undefined) => Pick<XapiStatement, '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<XapiStatement, '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: XapiStatement, verb: XapiStatement['verb'], result?: XapiStatement['result']) => Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'>;
+export declare const putAttemptActivityStatement: (gateway: LrsGateway, attemptStatement: XapiStatement, verb: XapiStatement['verb'], result?: XapiStatement['result']) => Promise<import(".").EagerXapiStatement>;
+export declare const createCompletedStatement: (attemptStatement: XapiStatement, result?: XapiStatement['result']) => Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'>;
+export declare const putCompletedStatement: (gateway: LrsGateway, attemptStatement: XapiStatement, result: XapiStatement['result']) => Promise<import(".").EagerXapiStatement>;

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

@@ -0,0 +1,270 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.putCompletedStatement = exports.createCompletedStatement = exports.putAttemptActivityStatement = exports.createAttemptActivityStatement = exports.putAttemptStatement = exports.createAttemptStatement = exports.createStatement = exports.loadActivityAttemptInfo = exports.loadStatementsForActivity = exports.loadStatementsForAttempt = exports.loadStatementsForActivityAndFirstChildren = exports.resolveActivityAttemptInfo = exports.mostRecentStatement = exports.resolveCompletedForAttempt = exports.resolveActivityAttempts = exports.matchAttemptCompleted = exports.matchAttempt = void 0;
+/*
+ * 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.
+ */
+const formatISODuration_1 = __importDefault(require("date-fns/formatISODuration"));
+const intervalToDuration_1 = __importDefault(require("date-fns/intervalToDuration"));
+const isAfter_1 = __importDefault(require("date-fns/isAfter"));
+const parseISO_1 = __importDefault(require("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 = {}));
+const matchAttempt = (statement) => statement.verb.id === Verb.Attempted;
+exports.matchAttempt = matchAttempt;
+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);
+};
+exports.matchAttemptCompleted = matchAttemptCompleted;
+const resolveActivityAttempts = (statements, activityIRI, parentActivityAttempt) => statements.filter(statement => {
+    var _a;
+    return (0, exports.matchAttempt)(statement)
+        && statement.object.id === activityIRI
+        && (!parentActivityAttempt || ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === parentActivityAttempt);
+});
+exports.resolveActivityAttempts = resolveActivityAttempts;
+const resolveCompletedForAttempt = (statements, activityIRI, attempt) => statements.find(statement => (0, exports.matchAttemptCompleted)(attempt)(statement)
+    && statement.object.id === activityIRI);
+exports.resolveCompletedForAttempt = resolveCompletedForAttempt;
+const mostRecentStatement = (statements) => statements.reduce((result, statement) => result && (0, isAfter_1.default)((0, parseISO_1.default)(result.timestamp), (0, parseISO_1.default)(statement.timestamp)) ? result : statement, statements[0]);
+exports.mostRecentStatement = mostRecentStatement;
+const resolveActivityAttemptInfo = (statements, activityIRI, 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 = (0, exports.resolveActivityAttempts)(statements, activityIRI, options === null || options === void 0 ? void 0 : options.parentActivityAttempt);
+    /* attempts that have a completed statement */
+    const completedAttempts = attempts.filter(attempt => !!(0, exports.resolveCompletedForAttempt)(statements, activityIRI, attempt));
+    /* the last attempt sorted by timestamp */
+    const currentAttempt = (options === null || options === void 0 ? void 0 : options.currentAttempt)
+        ? attempts.find(attempt => attempt.id === options.currentAttempt)
+        : (0, exports.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 statement.object.id === activityIRI
+            && ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === currentAttempt.id;
+    }) : [];
+    const currentAttemptCompleted = currentAttempt && (0, exports.resolveCompletedForAttempt)(statements, activityIRI, currentAttempt);
+    const mostRecentAttemptWithCompleted = completedAttempts.reduce((current, attempt) => current && (0, isAfter_1.default)((0, parseISO_1.default)(current.timestamp), (0, parseISO_1.default)(attempt.timestamp)) ? current : attempt, completedAttempts[0]);
+    const mostRecentAttemptWithCompletedCompleted = mostRecentAttemptWithCompleted
+        && (0, exports.resolveCompletedForAttempt)(statements, activityIRI, mostRecentAttemptWithCompleted);
+    /*
+     * 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,
+    };
+};
+exports.resolveActivityAttemptInfo = resolveActivityAttemptInfo;
+/*
+ * 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.
+ */
+const loadStatementsForActivityAndFirstChildren = (gateway, activityIRI, attempt) => {
+    return gateway.getAllXapiStatements({
+        activity: activityIRI,
+        related_activities: true,
+        ...(attempt ? { registration: attempt } : {})
+    });
+};
+exports.loadStatementsForActivityAndFirstChildren = loadStatementsForActivityAndFirstChildren;
+/*
+ * loads all statements (for this actor) that have the given parent attempt (registration)
+ */
+const loadStatementsForAttempt = (gateway, attempt) => {
+    return gateway.getAllXapiStatements({
+        registration: attempt
+    });
+};
+exports.loadStatementsForAttempt = loadStatementsForAttempt;
+/*
+ * loads all statements (for this actor) that have the given activityIRI as the object.id
+ */
+const loadStatementsForActivity = (gateway, activityIRI, attempt) => {
+    return gateway.getAllXapiStatements({
+        activity: activityIRI,
+        ...(attempt ? { registration: attempt } : {})
+    });
+};
+exports.loadStatementsForActivity = loadStatementsForActivity;
+const loadActivityAttemptInfo = async (gateway, activityIRI, options) => {
+    return (0, exports.resolveActivityAttemptInfo)(await (0, exports.loadStatementsForActivity)(gateway, activityIRI, options === null || options === void 0 ? void 0 : options.parentActivityAttempt), activityIRI, options);
+};
+exports.loadActivityAttemptInfo = loadActivityAttemptInfo;
+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,
+    };
+};
+exports.createStatement = createStatement;
+/*
+ * 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)
+ */
+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,
+        },
+    };
+};
+exports.createAttemptStatement = createAttemptStatement;
+/* resolves with the statement id */
+const putAttemptStatement = async (gateway, activity, parentActivity) => {
+    return await gateway.putXapiStatements([(0, exports.createAttemptStatement)(activity, parentActivity)])
+        .then(statements => statements[0]);
+};
+exports.putAttemptStatement = putAttemptStatement;
+/*
+ * creates a statement under the given attempt.
+ *
+ * `result` optional context for the attempt result (score, selected answer, etc)
+ */
+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 } : {}),
+    };
+};
+exports.createAttemptActivityStatement = createAttemptActivityStatement;
+const putAttemptActivityStatement = async (gateway, attemptStatement, verb, result) => {
+    return await gateway.putXapiStatements([(0, exports.createAttemptActivityStatement)(attemptStatement, verb, result)])
+        .then(statements => statements[0]);
+};
+exports.putAttemptActivityStatement = putAttemptActivityStatement;
+/*
+ * creates a statement that completes the given attempt.
+ *
+ * `result` optional context for the attempt result (score, selected answer, etc)
+ */
+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: (0, formatISODuration_1.default)((0, intervalToDuration_1.default)({
+                start: (0, parseISO_1.default)(attemptStatement.timestamp), end: new Date()
+            })),
+            ...result,
+        }
+    };
+};
+exports.createCompletedStatement = createCompletedStatement;
+const putCompletedStatement = async (gateway, attemptStatement, result) => {
+    return await gateway.putXapiStatements([(0, exports.createCompletedStatement)(attemptStatement, result)])
+        .then(statements => statements[0]);
+};
+exports.putCompletedStatement = putCompletedStatement;

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

@@ -0,0 +1,15 @@
+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) => LrsGateway;
+export {};

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

@@ -0,0 +1,126 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileSystemLrsGateway = void 0;
+const fsModule = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const formatISO_1 = __importDefault(require("date-fns/formatISO"));
+const uuid_1 = require("uuid");
+const assertions_1 = require("../../assertions");
+const config_1 = require("../../config");
+const errors_1 = require("../../errors");
+const guards_1 = require("../../guards");
+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) => {
+            if (err) {
+                console.error(err);
+            }
+            else {
+                try {
+                    data = JSON.parse(readData.toString());
+                    if (typeof data !== 'object' || !(data instanceof Array)) {
+                        data = undefined;
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            resolve();
+        });
+    }));
+    let previousSave;
+    const putXapiStatements = async (statements) => {
+        const user = (0, assertions_1.assertDefined)(await authProvider.getUser(), new errors_1.UnauthorizedError);
+        const statementsWithDefaults = statements.map(statement => ({
+            ...statement,
+            id: (0, uuid_1.v4)(),
+            actor: {
+                account: {
+                    homePage: 'https://openstax.org',
+                    name: user.uuid,
+                },
+                objectType: 'Agent',
+            },
+            timestamp: (0, formatISO_1.default)(new Date()),
+        }));
+        await load;
+        await previousSave;
+        const path = await filePath;
+        const save = previousSave = new Promise(resolve => {
+            data = data || [];
+            data.push(...statementsWithDefaults.map(statement => ({ ...statement, stored: statement.timestamp })));
+            writeFile(path, JSON.stringify(data, null, 2), () => resolve());
+        });
+        await save;
+        return statementsWithDefaults;
+    };
+    const getAllXapiStatements = async ({ user, anyUser, ...options }) => {
+        const authUser = await authProvider.getUser();
+        await load;
+        return (data || []).filter(statement => {
+            var _a, _b, _c, _d;
+            return (anyUser === true || statement.actor.account.name === (user || (0, assertions_1.assertDefined)(authUser, new errors_1.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')));
+        });
+    };
+    const getMoreXapiStatements = async (more) => {
+        const { args, offset } = JSON.parse(more);
+        const allResults = await getAllXapiStatements(...args);
+        const end = offset + pageSize;
+        return {
+            more: allResults.length > end ? JSON.stringify({ args, offset: end }) : '',
+            statements: allResults.slice(offset, end)
+        };
+    };
+    const getXapiStatements = async (...args) => {
+        const allResults = await getAllXapiStatements(...args);
+        return {
+            more: allResults.length > pageSize ? JSON.stringify({ args, offset: pageSize }) : '',
+            statements: allResults.slice(0, pageSize)
+        };
+    };
+    return {
+        putXapiStatements,
+        getAllXapiStatements,
+        getXapiStatements,
+        getMoreXapiStatements,
+    };
+};
+exports.fileSystemLrsGateway = fileSystemLrsGateway;