@openstax/ts-utils 1.21.11 → 1.23.0

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

@@ -0,0 +1,110 @@
+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, fetchUntil, ...options }) => {
+        const authUser = await authProvider.getUser();
+        await load;
+        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')))
+                && (!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);
+        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,125 @@
+import { ConfigProviderForConfig } from '../../config';
+import { GenericFetch } from '../../fetch';
+import { WithRequired } from '../../types';
+import { AuthProvider } from '../authProvider';
+import { Logger } from '../logger';
+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 UXapiStatement = XapiStatement | EagerXapiStatement | SavedXapiStatement;
+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, logger }: {
+    authProvider: AuthProvider;
+    logger: Logger;
+}) => {
+    putXapiStatements: (statements: Array<(Pick<XapiStatement, 'object' | 'verb' | 'context' | 'result'> & {
+        id?: string;
+    }) | UXapiStatement>) => Promise<EagerXapiStatement[]>;
+    getXapiStatements: (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;
+    }) => Promise<{
+        more: string;
+        statements: XapiStatement[];
+    }>;
+    getMoreXapiStatements: (more: string) => Promise<{
+        more: string;
+        statements: XapiStatement[];
+    }>;
+    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

@@ -0,0 +1,111 @@
+import * as queryString from 'query-string';
+import { once } from '../..';
+import { assertDefined } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { UnauthorizedError } from '../../errors';
+import { fetchStatusRetry } from '../../fetch/fetchStatusRetry';
+import { ifDefined } from '../../guards';
+import { retryWithDelay } from '../../misc/helpers';
+import { METHOD } from '../../routing';
+import { addStatementDefaultFields } from './addStatementDefaultFields';
+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, logger }) => {
+        const fetcher = fetchStatusRetry(initializer.fetch, {
+            logger,
+            retries: 2,
+            wait: 1000,
+            status: [502]
+        });
+        // Note: This method actually uses POST
+        const putXapiStatements = async (statements) => {
+            const user = assertDefined(await authProvider.getUser(), new UnauthorizedError);
+            const statementsWithDefaults = statements.map(statement => addStatementDefaultFields(statement, user));
+            const response = await fetcher((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,
+            });
+            if (![200, 201].includes(response.status)) {
+                throw new Error(`Unexpected LRS POST statements response code ${response.status} with body:
+
+${await response.text()}`);
+            }
+            await response.json();
+            return statementsWithDefaults;
+        };
+        // Note: This code does not currently handle a single statement response,
+        // which can return 404 if the statement is not found
+        const formatGetXapiStatementsResponse = async (response) => {
+            if (response.status !== 200) {
+                throw new Error(`Unexpected LRS GET statements response code ${response.status} with body:
+
+${await response.text()}`);
+            }
+            return response.json();
+        };
+        const getMoreXapiStatements = async (more) => fetcher((await lrsHost()).replace(/\/+$/, '') + more, {
+            headers: {
+                Authorization: await lrsAuthorization(),
+                'X-Experience-API-Version': '1.0.0',
+            },
+        }).then(formatGetXapiStatementsResponse);
+        const fetchXapiStatements = async ({ user, anyUser, ...options }) => fetcher((await lrsHost()).replace(/\/+$/, '') + '/data/xAPI/statements?' + queryString.stringify({
+            ...options,
+            ...(anyUser === true ? {} : {
+                agent: JSON.stringify({
+                    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',
+            },
+        });
+        const getXapiStatements = async (params) => {
+            const { ensureSync, ...fetchParams } = params;
+            if (ensureSync) {
+                const date = new Date();
+                return retryWithDelay(async (abort) => {
+                    // this function retries for the consistency, if the fetch errors just abort
+                    const response = await fetchXapiStatements(fetchParams).catch(abort);
+                    const consistentThrough = response.headers.get('X-Experience-API-Consistent-Through');
+                    if (!consistentThrough || new Date(consistentThrough) < date) {
+                        throw new Error(`xAPI consistent through ${consistentThrough}; not in sync with current date ${date.toISOString()}.`);
+                    }
+                    return formatGetXapiStatementsResponse(response);
+                }, { retries: 4, logger });
+            }
+            else {
+                return fetchXapiStatements(fetchParams).then(formatGetXapiStatementsResponse);
+            }
+        };
+        const getAllXapiStatements = async ({ fetchUntil, ...params }) => {
+            const loadRemaining = async (result) => {
+                if (!result.more || (fetchUntil && fetchUntil(result.statements))) {
+                    return result.statements;
+                }
+                const { more, statements } = await getMoreXapiStatements(result.more);
+                return loadRemaining({ more, statements: [...result.statements, ...statements] });
+            };
+            return loadRemaining(await getXapiStatements(params));
+        };
+        return {
+            putXapiStatements,
+            getXapiStatements,
+            getMoreXapiStatements,
+            getAllXapiStatements,
+        };
+    };
+};

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

@@ -0,0 +1,61 @@
+import { AccountsGateway, MappedUserInfo } from '../accountsGateway';
+import { AuthProvider } from '../authProvider';
+import { Logger } from '../logger';
+import { ActivityState } from './attempt-utils';
+import { LrsGateway } from '.';
+export interface Grade {
+    scoreGiven: number;
+    scoreMaximum: number;
+    comment?: string;
+    activityProgress: 'Initialized' | 'Started' | 'inProgress' | 'Submitted' | 'Completed';
+    gradingProgress: 'FullyGraded' | 'Pending' | 'PendingManual' | 'Failed' | 'NotReady';
+    userId?: string;
+}
+export declare const getRegistrationAttemptInfo: (lrs: LrsGateway, registration: string, options?: {
+    activity?: string | undefined;
+    anyUser?: boolean | undefined;
+    currentPreference?: "latest" | "oldest" | undefined;
+    ensureSync?: boolean | undefined;
+    user?: string | undefined;
+} | undefined) => Promise<{
+    [key: string]: ActivityState;
+}>;
+export declare const getScoreGrade: (score: {
+    scaled?: number;
+    raw?: number;
+    min?: number;
+    max?: number;
+}, completed: boolean, userId?: string | undefined, maxScore?: number | undefined) => Grade;
+export declare type Progress = {
+    scaled: number;
+    max?: number;
+    raw?: number;
+};
+export declare type GradeAndProgress = {
+    grade: Grade;
+    progress: Progress;
+    name?: string;
+};
+export declare const getCurrentGrade: (services: {
+    lrs: LrsGateway;
+    ltiAuthProvider: AuthProvider;
+}, registration: string, options?: {
+    currentPreference?: "latest" | "oldest" | undefined;
+    incompleteAttemptCallback?: ((info: ActivityState) => Promise<GradeAndProgress>) | undefined;
+    name?: string | undefined;
+    scoreMaximum?: number | undefined;
+    userId?: string | undefined;
+} | undefined) => Promise<GradeAndProgress | null>;
+export declare type UserActivityInfo = MappedUserInfo<ActivityState>;
+export declare const getAssignmentGrades: (services: {
+    accountsGateway: AccountsGateway;
+    lrs: LrsGateway;
+    logger: Logger;
+}, assignmentIRI: string, registration: string, options?: {
+    anyUser?: boolean | undefined;
+    currentPreference?: "latest" | "oldest" | undefined;
+    incompleteAttemptsCallback?: ((mappedInfo: UserActivityInfo[]) => Promise<GradeAndProgress[]>) | undefined;
+    platformId?: string | undefined;
+    scoreMaximum?: number | undefined;
+    user?: string | undefined;
+} | undefined) => Promise<GradeAndProgress[]>;

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

@@ -0,0 +1,84 @@
+import partition from 'lodash/fp/partition';
+import { roundToPrecision } from '../..';
+import { resolveAttemptInfo } from './attempt-utils';
+export const getRegistrationAttemptInfo = async (lrs, registration, options) => {
+    const { currentPreference, ...xapiOptions } = options !== null && options !== void 0 ? options : {};
+    const allStatements = await lrs.getAllXapiStatements({ ...xapiOptions, registration });
+    // Partition statements for each user
+    const statementsPerUser = {};
+    allStatements.forEach((statement) => {
+        var _a;
+        // If we ever support accounts from different statement.actor.account.homePage, this method may need changes
+        // (unless we can guarantee the statement.actor.account.name are unique)
+        statementsPerUser[_a = statement.actor.account.name] || (statementsPerUser[_a] = []);
+        statementsPerUser[statement.actor.account.name].push(statement);
+    });
+    const result = {};
+    for (const [userUuid, userStatements] of Object.entries(statementsPerUser)) {
+        result[userUuid] = resolveAttemptInfo(userStatements, { currentPreference });
+    }
+    return result;
+};
+// generates a payload that can be sent to the LMS, documentation here:
+// lti: http://www.imsglobal.org/spec/lti-ags/v2p0#score-publish-service
+// ltijs: https://cvmcosta.me/ltijs/#/grading
+export const getScoreGrade = (score, completed, userId, maxScore) => {
+    const { raw, scaled, max } = score;
+    const scoreMaximum = maxScore !== null && maxScore !== void 0 ? maxScore : 100;
+    const scoreGiven = raw && max
+        ? scoreMaximum / max * raw
+        : scaled
+            ? scaled * scoreMaximum
+            : 0;
+    return {
+        userId,
+        activityProgress: completed ? 'Completed' : 'Started',
+        // canvas assumes that anything that isn't 'FullyGraded' requires manual grading and displays a "needs grading" icon.
+        // if you warp your mind you can consider the portion of the assignment which is completed to be fully graded.
+        gradingProgress: 'FullyGraded',
+        scoreMaximum,
+        scoreGiven: roundToPrecision(scoreGiven, -2),
+    };
+};
+// These methods assign 0's to incomplete activities
+const getCompletedActivityStateGradeAndProgress = ({ name, scoreMaximum, state, userId }) => {
+    var _a, _b;
+    return ({
+        grade: getScoreGrade(((_b = (_a = state.currentAttemptCompleted) === null || _a === void 0 ? void 0 : _a.result) === null || _b === void 0 ? void 0 : _b.score) || {}, !!state.currentAttemptCompleted, userId, scoreMaximum),
+        progress: {
+            scaled: state.currentAttemptCompleted ? 1 : 0,
+        },
+        name,
+    });
+};
+const getCompletedUserInfosGradeAndProgress = (infos, scoreMaximum) => infos.map(({ data, fullName, platformUserId }) => getCompletedActivityStateGradeAndProgress({
+    name: fullName, scoreMaximum, userId: platformUserId, state: data
+}));
+export const getCurrentGrade = async (services, registration, options) => {
+    var _a;
+    const user = await services.ltiAuthProvider.getUser();
+    if (!user) {
+        return null;
+    }
+    const userId = (_a = options === null || options === void 0 ? void 0 : options.userId) !== null && _a !== void 0 ? _a : user.uuid;
+    const { currentPreference, incompleteAttemptCallback, name, scoreMaximum } = options !== null && options !== void 0 ? options : {};
+    const infoPerUser = await getRegistrationAttemptInfo(services.lrs, registration, { currentPreference });
+    const userInfo = infoPerUser[user.uuid];
+    if (!userInfo) {
+        return getCompletedActivityStateGradeAndProgress({ name, scoreMaximum, state: resolveAttemptInfo([]), userId });
+    }
+    if (userInfo.currentAttemptCompleted || !incompleteAttemptCallback) {
+        return getCompletedActivityStateGradeAndProgress({ name, scoreMaximum, state: userInfo, userId });
+    }
+    return incompleteAttemptCallback(userInfo);
+};
+export const getAssignmentGrades = async (services, assignmentIRI, registration, options) => {
+    const { anyUser, currentPreference, incompleteAttemptsCallback, platformId, scoreMaximum, user } = options !== null && options !== void 0 ? options : {};
+    const infoPerUserUuid = await getRegistrationAttemptInfo(services.lrs, registration, { activity: assignmentIRI, anyUser, currentPreference, user });
+    const mappedInfo = await services.accountsGateway.mapUserUuids(infoPerUserUuid, services.logger, platformId);
+    if (!incompleteAttemptsCallback) {
+        return getCompletedUserInfosGradeAndProgress(mappedInfo, scoreMaximum);
+    }
+    const [incompleteInfo, completedInfo] = partition((info) => info.data.currentAttemptCompleted === undefined)(mappedInfo);
+    return getCompletedUserInfosGradeAndProgress(completedInfo, scoreMaximum).concat(await incompleteAttemptsCallback(incompleteInfo));
+};

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

@@ -0,0 +1,35 @@
+import postgres, { Sql } from 'postgres';
+import { ConfigProviderForConfig } from '../../config';
+import type { Logger } from '../logger';
+declare type Config = {
+    host: string;
+    readHost: string;
+    port: string;
+    database: string;
+    username: string;
+    password: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+}
+export declare const postgresConnection: <C extends string = "local">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    host: import("../../config").ConfigValueProvider<string>;
+    readHost: import("../../config").ConfigValueProvider<string>;
+    port: import("../../config").ConfigValueProvider<string>;
+    database: import("../../config").ConfigValueProvider<string>;
+    username: import("../../config").ConfigValueProvider<string>;
+    password: import("../../config").ConfigValueProvider<string>;
+}; }) => (services: {
+    logger: Logger;
+}) => {
+    db: () => Promise<postgres.Sql<{}>>;
+    dbRead: () => Promise<postgres.Sql<{}>>;
+    migrate: (migrations: Migration[]) => Promise<void>;
+    down: () => Promise<void[]>;
+};
+export declare type PostgresConnection = ReturnType<ReturnType<ReturnType<typeof postgresConnection>>>;
+export interface Migration {
+    name: string;
+    up: (db: Sql) => Promise<void>;
+}
+export {};

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

@@ -0,0 +1,56 @@
+import postgres from 'postgres';
+import { assertNotNaN } from '../../assertions';
+import { resolveConfigValue } from '../../config';
+import { ifDefined } from '../../guards';
+import { once } from '../../misc/helpers';
+export const postgresConnection = (initializer) => (configProvider) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'local')];
+    const host = once(() => resolveConfigValue(config.host));
+    const readHost = once(() => resolveConfigValue(config.readHost));
+    const connectionOptions = once(async () => ({
+        port: assertNotNaN(parseInt(await resolveConfigValue(config.port), 10), new Error('port must be a number')),
+        database: await resolveConfigValue(config.database),
+        username: await resolveConfigValue(config.username),
+        password: await resolveConfigValue(config.password),
+        transform: postgres.camel,
+    }));
+    const connections = [];
+    const sql = once(async () => {
+        const options = await connectionOptions();
+        const connection = postgres({ ...options, host: await host() });
+        connections.push(connection);
+        return connection;
+    });
+    const sqlRead = once(async () => {
+        const options = await connectionOptions();
+        const connection = postgres({ ...options, host: await readHost() });
+        connections.push(connection);
+        return connection;
+    });
+    return (services) => ({
+        db: sql,
+        dbRead: sqlRead,
+        migrate: async (migrations) => {
+            await migrate(services, await sql(), migrations);
+        },
+        down: () => Promise.all(connections.map(c => c.end()))
+    });
+};
+async function migrate(services, db, migrations) {
+    await db `
+    CREATE TABLE IF NOT EXISTS migrations (
+      id SERIAL PRIMARY KEY,
+      name TEXT NOT NULL,
+      ran_at TIMESTAMP NOT NULL DEFAULT NOW()
+    )
+  `;
+    const ranMigrations = await db `SELECT name FROM migrations`;
+    for (const migration of migrations) {
+        if (ranMigrations.some(({ name }) => name === migration.name)) {
+            continue;
+        }
+        services.logger.log(`Running migration ${migration.name}`);
+        await migration.up(db);
+        await db `INSERT INTO migrations (name) VALUES (${migration.name})`;
+    }
+}

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

@@ -0,0 +1,31 @@
+export declare type Filter = {
+    key: string;
+    value: string | string[] | boolean;
+};
+declare type Field = {
+    key: string;
+    type?: 'text';
+    weight: number;
+} | {
+    key: string;
+    type: 'keyword';
+} | {
+    key: string;
+    type: 'boolean';
+};
+export interface IndexOptions<T> {
+    body: T;
+    id: string;
+}
+export interface SearchOptions {
+    page?: number;
+    query: string | undefined;
+    fields: Field[];
+    /**
+     * @deprecated use `must` instead
+     */
+    filter?: Filter[];
+    must?: Filter[];
+    must_not?: Filter[];
+}
+export {};

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

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

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

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