@openstax/ts-utils 1.1.27 → 1.1.29

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

@@ -0,0 +1,251 @@
+/*
+ * 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 resolveActivityAttempts = (statements, activityIRI, parentActivityAttempt) => 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);
+});
+export const resolveCompletedForAttempt = (statements, activityIRI, attempt) => statements.find(statement => matchAttemptCompleted(attempt)(statement)
+    && 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) => {
+    // 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);
+    /* attempts that have a completed statement */
+    const completedAttempts = attempts.filter(attempt => !!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)
+        : (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 statement.object.id === activityIRI
+            && ((_a = statement.context) === null || _a === void 0 ? void 0 : _a.registration) === currentAttempt.id;
+    }) : [];
+    const currentAttemptCompleted = currentAttempt && resolveCompletedForAttempt(statements, activityIRI, currentAttempt);
+    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);
+    /*
+     * 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 `loadStatementsForActivity(gateway, childActivityIRI, childAttemptStatementID)`. this
+ * is because child activities could have multiple attempts under one attempt on the parent activity.
+ */
+export const loadStatementsForActivityAndFirstChildren = (gateway, activityIRI, attempt) => {
+    return gateway.getAllXapiStatements({
+        activity: activityIRI,
+        related_activities: true,
+        ...(attempt ? { registration: attempt } : {})
+    });
+};
+/*
+ * loads all statements (for this actor) that have the given parent attempt (registration)
+ */
+export const loadStatementsForAttempt = (gateway, attempt) => {
+    return gateway.getAllXapiStatements({
+        registration: attempt
+    });
+};
+/*
+ * loads all statements (for this actor) that have the given activityIRI as the object.id
+ */
+export const loadStatementsForActivity = (gateway, activityIRI, attempt) => {
+    return gateway.getAllXapiStatements({
+        activity: activityIRI,
+        ...(attempt ? { registration: attempt } : {})
+    });
+};
+export const loadActivityAttemptInfo = async (gateway, activityIRI, options) => {
+    return resolveActivityAttemptInfo(await loadStatementsForActivity(gateway, activityIRI, options === null || options === void 0 ? void 0 : options.parentActivityAttempt), activityIRI, options);
+};
+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)])
+        .then(statements => statements[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)])
+        .then(statements => statements[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)])
+        .then(statements => statements[0]);
+};

package/dist/esm/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/esm/services/lrsGateway/file-system.js

@@ -0,0 +1,96 @@
+import * as fsModule from 'fs';
+import path from 'path';
+import formatISO from 'date-fns/formatISO';
+import { v4 as uuid } from 'uuid';
+import { assertDefined } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { UnauthorizedError } from '../../errors';
+import { ifDefined } from '../../guards';
+const pageSize = 5;
+export const fileSystemLrsGateway = (initializer) => (configProvider) => (authProvider) => {
+    const name = resolveConfigValue(configProvider[initializer.configSpace || 'fileSystem'].name);
+    const filePath = name.then((fileName) => path.join(initializer.dataDir, fileName));
+    const { readFile, writeFile } = 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 = assertDefined(await authProvider.getUser(), new UnauthorizedError);
+        const statementsWithDefaults = statements.map(statement => ({
+            ...statement,
+            id: uuid(),
+            actor: {
+                account: {
+                    homePage: 'https://openstax.org',
+                    name: user.uuid,
+                },
+                objectType: 'Agent',
+            },
+            timestamp: formatISO(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 || 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')));
+        });
+    };
+    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,
+    };
+};

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

@@ -0,0 +1,110 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { WithRequired } from '../../types';
+import { AuthProvider } from '../authProvider';
+declare type Config = {
+    lrsHost: string;
+    lrsAuthorization: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    fetch: GenericFetch;
+}
+export interface XapiStatement {
+    actor: {
+        account: {
+            homePage: 'https://openstax.org';
+            name: string;
+        };
+        objectType: 'Agent';
+    };
+    id: string;
+    context?: {
+        contextActivities?: {
+            parent?: [
+                {
+                    id: string;
+                    objectType: 'Activity';
+                }
+            ];
+        };
+        statement?: {
+            objectType: 'StatementRef';
+            id: string;
+        };
+        registration?: string;
+        platform?: string;
+    };
+    object: {
+        definition?: {
+            extensions?: {
+                [key: string]: string;
+            };
+            name: {
+                [key: string]: string;
+            };
+            type: string;
+        };
+        id: string;
+        objectType: 'Activity';
+    };
+    result?: {
+        score?: {
+            scaled?: number;
+            raw?: number;
+            min?: number;
+            max?: number;
+        };
+        success?: boolean;
+        completion?: boolean;
+        response?: string;
+        duration?: string;
+        extensions?: {
+            [key: string]: string;
+        };
+    };
+    verb: {
+        display?: {
+            [key: string]: string;
+        };
+        id: string;
+    };
+    timestamp: string;
+    stored?: string;
+}
+export declare type SavedXapiStatement = WithRequired<XapiStatement, 'stored'>;
+export declare type EagerXapiStatement = Omit<XapiStatement, 'stored'>;
+export declare type LrsGateway = ReturnType<ReturnType<ReturnType<typeof lrsGateway>>>;
+export declare type LrsProvider = ReturnType<ReturnType<typeof lrsGateway>>;
+export declare const lrsGateway: <C extends string = "lrs">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    lrsHost: import("../../config").ConfigValueProvider<string>;
+    lrsAuthorization: import("../../config").ConfigValueProvider<string>;
+}; }) => (authProvider: AuthProvider) => {
+    putXapiStatements: (statements: Array<Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+        id?: string;
+    }>) => Promise<EagerXapiStatement[]>;
+    getXapiStatements: ({ user, anyUser, ...options }: {
+        verb?: string | undefined;
+        activity?: string | undefined;
+        registration?: string | undefined;
+        related_activities?: boolean | undefined;
+        user?: string | undefined;
+        anyUser?: boolean | undefined;
+    }) => Promise<{
+        more: string;
+        statements: XapiStatement[];
+    }>;
+    getMoreXapiStatements: (more: string) => Promise<{
+        more: string;
+        statements: XapiStatement[];
+    }>;
+    getAllXapiStatements: (args_0: {
+        verb?: string | undefined;
+        activity?: string | undefined;
+        registration?: string | undefined;
+        related_activities?: boolean | undefined;
+        user?: string | undefined;
+        anyUser?: boolean | undefined;
+    }) => Promise<XapiStatement[]>;
+};
+export {};

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

@@ -0,0 +1,87 @@
+import formatISO from 'date-fns/formatISO';
+import * as queryString from 'query-string';
+import { once } from '../..';
+import { assertDefined } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { UnauthorizedError } from '../../errors';
+import { ifDefined } from '../../guards';
+import { METHOD } from '../../routing';
+export const lrsGateway = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'lrs')];
+    const lrsHost = once(() => resolveConfigValue(config.lrsHost));
+    const lrsAuthorization = once(() => resolveConfigValue(config.lrsAuthorization));
+    return (authProvider) => {
+        const putXapiStatements = async (statements) => {
+            const user = assertDefined(await authProvider.getUser(), new UnauthorizedError);
+            const statementsWithDefaults = statements.map(statement => ({
+                ...statement,
+                actor: {
+                    account: {
+                        homePage: 'https://openstax.org',
+                        name: user.uuid,
+                    },
+                    objectType: 'Agent',
+                },
+                timestamp: formatISO(new Date())
+            }));
+            return initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements', {
+                body: JSON.stringify(statementsWithDefaults),
+                headers: {
+                    Authorization: await lrsAuthorization(),
+                    'Content-Type': 'application/json',
+                    'X-Experience-API-Version': '1.0.0',
+                },
+                method: METHOD.POST,
+            })
+                .then(response => response.json())
+                .then(ids => ids.map((id, index) => ({ id, ...statementsWithDefaults[index] })));
+        };
+        const getMoreXapiStatements = async (more) => {
+            return initializer.fetch((await lrsHost()).replace(/\/+$/, '') + more, {
+                headers: {
+                    Authorization: await lrsAuthorization(),
+                    'X-Experience-API-Version': '1.0.0',
+                },
+            })
+                .then(response => response.json())
+                .then(json => json);
+        };
+        const getXapiStatements = async ({ user, anyUser, ...options }) => {
+            return initializer.fetch((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
+                ...options,
+                ...(anyUser === true ? {} : {
+                    agent: JSON.stringify({
+                        account: {
+                            homePage: 'https://openstax.org',
+                            name: user || assertDefined(await authProvider.getUser(), new UnauthorizedError()).uuid,
+                        },
+                        objectType: 'Agent',
+                    }),
+                })
+            }), {
+                headers: {
+                    Authorization: await lrsAuthorization(),
+                    'X-Experience-API-Version': '1.0.0',
+                },
+            })
+                .then(response => response.json())
+                .then(json => json);
+        };
+        const getAllXapiStatements = (...args) => {
+            const loadRemaining = async (result) => {
+                if (!result.more) {
+                    return result.statements;
+                }
+                const { more, statements } = await getMoreXapiStatements(result.more);
+                return loadRemaining({ more, statements: [...result.statements, ...statements] });
+            };
+            return getXapiStatements(...args).then(loadRemaining);
+        };
+        return {
+            putXapiStatements,
+            getXapiStatements,
+            getMoreXapiStatements,
+            getAllXapiStatements,
+        };
+    };
+};

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

@@ -0,0 +1,19 @@
+declare type Filter = {
+    key: string;
+    value: string | string[];
+};
+declare type Field = {
+    key: string;
+    type?: 'text';
+    weight: number;
+} | {
+    key: string;
+    type: 'keyword';
+};
+export interface SearchOptions {
+    page?: number;
+    query: string | undefined;
+    fields: Field[];
+    filter?: Filter[];
+}
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/services/searchProvider/memorySearchTheBadWay.d.ts

@@ -0,0 +1,12 @@
+import { SearchOptions } from '.';
+export declare const memorySearchTheBadWay: <T>({ loadAllDocumentsTheBadWay }: {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+}) => {
+    search: (options: SearchOptions) => Promise<{
+        items: T[];
+        pageSize: number;
+        currentPage: number;
+        totalItems: number;
+        totalPages: number;
+    }>;
+};

package/dist/esm/services/searchProvider/memorySearchTheBadWay.js

@@ -0,0 +1,53 @@
+import { coerceArray } from '../..';
+import { isDefined } from '../../guards';
+const MIN_MATCH = 0.5;
+const MAX_RESULTS = 10;
+const resolveField = (document, field) => field.key.toString().split('.').reduce((result, key) => result[key], document);
+export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
+    return {
+        search: async (options) => {
+            const results = (await loadAllDocumentsTheBadWay())
+                .map(document => {
+                let weight = 0;
+                if (options.query !== undefined) {
+                    for (const field of options.fields) {
+                        if (field.type !== undefined && field.type !== 'text') {
+                            continue;
+                        }
+                        const value = resolveField(document, field);
+                        if (value === undefined || value === null) {
+                            continue;
+                        }
+                        if (typeof value === 'string') {
+                            if (value.toUpperCase().indexOf(options.query.toUpperCase()) !== -1) {
+                                weight += (1 * field.weight);
+                            }
+                        }
+                        else {
+                            throw new Error(`invalid value type when searching in field ${field.key.toString()}`);
+                        }
+                    }
+                }
+                for (const field of options.filter || []) {
+                    const value = resolveField(document, field);
+                    if (!coerceArray(field.value).some(v => coerceArray(value).includes(v))) {
+                        return undefined;
+                    }
+                }
+                return { document, weight };
+            })
+                .filter(isDefined)
+                .filter(r => !options.query || r.weight >= MIN_MATCH);
+            results.sort((a, b) => b.weight - a.weight);
+            const page = options.page || 1;
+            const offset = (page - 1) * MAX_RESULTS;
+            return {
+                items: results.slice(offset, offset + MAX_RESULTS).map(r => r.document),
+                pageSize: MAX_RESULTS,
+                currentPage: page,
+                totalItems: results.length,
+                totalPages: Math.ceil(results.length / MAX_RESULTS)
+            };
+        }
+    };
+};

package/dist/esm/services/versionedDocumentStore/dynamodb.d.ts

@@ -0,0 +1,23 @@
+import { ConfigProviderForConfig } from '../../config';
+import { Track } from '../../profile';
+import { TDocument, VersionedDocumentAuthor } from '.';
+declare type DynamoConfig = {
+    tableName: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+}
+export declare const dynamoVersionedDocumentStore: <C extends string = "dynamodb">(initializer?: Initializer<C> | undefined) => <T extends TDocument<T>>() => (configProvider: { [key in C]: {
+    tableName: import("../../config").ConfigValueProvider<string>;
+}; }) => <K extends keyof T, A extends ((...a: any[]) => Promise<VersionedDocumentAuthor>) | undefined>({ profile }: {
+    profile: Track;
+}, hashKey: K, getAuthor: A) => {
+    loadAllDocumentsTheBadWay: () => Promise<T[]>;
+    getVersions: (id: T[K], startVersion?: number | undefined) => Promise<{
+        items: T[];
+        nextPageToken: number | undefined;
+    } | undefined>;
+    getItem: (id: T[K], timestamp?: number | undefined) => Promise<T | undefined>;
+    putItem: (item: Omit<T, "timestamp" | "author">, ...authorArgs: A extends Function ? Parameters<A> : [VersionedDocumentAuthor]) => Promise<T>;
+};
+export {};