@openstax/ts-utils 1.3.0 → 1.3.2

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
-declare type Filter = {
+export declare type Filter = {
     key: string;
-    value: string | string[];
+    value: string | string[] | boolean;
 };
 declare type Field = {
     key: string;
@@ -9,6 +9,9 @@ declare type Field = {
 } | {
     key: string;
     type: 'keyword';
+} | {
+    key: string;
+    type: 'boolean';
 };
 export interface IndexOptions<T> {
     body: T;
@@ -18,6 +21,11 @@ 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/memorySearchTheBadWay.js

@@ -1,16 +1,41 @@
 import { coerceArray } from '../..';
+import { InvalidRequestError } from '../../errors';
 import { isDefined } from '../../guards';
 const MIN_MATCH = 0.5;
 const MAX_RESULTS = 10;
+var MatchType;
+(function (MatchType) {
+    MatchType[MatchType["Must"] = 0] = "Must";
+    MatchType[MatchType["MustNot"] = 1] = "MustNot";
+})(MatchType || (MatchType = {}));
 const resolveField = (document, field) => field.key.toString().split('.').reduce((result, key) => result[key], document);
 export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
     return {
         ensureIndexCreated: async () => undefined,
         index: async (_options) => undefined,
         search: async (options) => {
+            const getFieldType = (field) => { var _a; return (_a = options.fields.find(f => f.key == field.key)) === null || _a === void 0 ? void 0 : _a.type; };
             const results = (await loadAllDocumentsTheBadWay())
                 .map(document => {
                 let weight = 0;
+                const matchFilters = (filters, mustMatch) => {
+                    for (const field of filters) {
+                        const docValues = coerceArray(resolveField(document, field));
+                        const coerceValue = getFieldType(field) === 'boolean'
+                            ? (input) => {
+                                if ([true, 'true', '1', 1].includes(input)) {
+                                    return true;
+                                }
+                                if ([false, 'false', '0', 0, ''].includes(input)) {
+                                    return false;
+                                }
+                                throw new InvalidRequestError('input is not a valid boolean filter');
+                            }
+                            : (x) => x;
+                        const hasMatch = coerceArray(field.value).map(coerceValue).some(v => docValues.includes(v));
+                        return !((mustMatch === MatchType.Must && !hasMatch) || (mustMatch === MatchType.MustNot && hasMatch));
+                    }
+                };
                 if (options.query !== undefined) {
                     for (const field of options.fields) {
                         if (field.type !== undefined && field.type !== 'text') {
@@ -30,11 +55,13 @@ export const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                         }
                     }
                 }
-                for (const field of options.filter || []) {
-                    const value = resolveField(document, field);
-                    if (!coerceArray(field.value).some(v => coerceArray(value).includes(v))) {
-                        return undefined;
-                    }
+                const { must_not } = options;
+                const must = 'filter' in options ? options.filter : options.must;
+                if ((must === null || must === void 0 ? void 0 : must.length) && !matchFilters(must, MatchType.Must)) {
+                    return undefined;
+                }
+                if ((must_not === null || must_not === void 0 ? void 0 : must_not.length) && !matchFilters(must_not, MatchType.MustNot)) {
+                    return undefined;
                 }
                 return { document, weight };
             })