@openstax/ts-utils 1.21.11 → 1.23.0

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

@@ -0,0 +1,85 @@
+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));
+                        if ((mustMatch === MatchType.Must && !hasMatch) || (mustMatch === MatchType.MustNot && hasMatch)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                };
+                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()}`);
+                        }
+                    }
+                }
+                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 };
+            })
+                .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)
+            };
+        },
+    };
+};