@openstax/ts-utils 1.33.0 → 1.34.0

package/packages/utils/src/services/searchProvider/memorySearchTheBadWay.ts

@@ -0,0 +1,223 @@
+import { coerceArray } from '../..';
+import { InvalidRequestError } from '../../errors';
+import { isDefined } from '../../guards';
+import { BoolFilter, FieldMappings, FieldType, Filter, IndexOptions, SearchOptions } from '.';
+
+const MIN_MATCH = 0.5;
+const MAX_RESULTS = 10;
+
+enum MatchType {
+  Must,
+  MustNot,
+  Should
+}
+
+type QueryContext = {
+  fields: FieldMappings;
+  scope: string;
+  document: any;
+};
+
+const resolveField = (context: QueryContext, field: string) => {
+  const path = field.startsWith(context.scope + '.')
+    ? field.slice(context.scope.length + 1)
+    : field;
+  return path.split('.').reduce((result: any, key: string) => {
+    if (result === undefined) {
+      throw new Error(`Key "${key}" not found in document resolving ${field}`);
+    }
+    return result[key];
+  }, context.document);
+};
+
+const getFieldDefinition = (context: QueryContext, field: string) => {
+  let current: FieldMappings = context.fields;
+  const parts = field.split('.');
+  const head = parts.slice(0, -1);
+  const tail = parts[parts.length - 1];
+
+  for (const part of head) {
+    const currentDefinition = current[part];
+    if (!currentDefinition || !('properties' in currentDefinition)) {
+      throw new Error(`Field "${field}" not found in mappings`);
+    }
+    current = currentDefinition.properties;
+  }
+
+  if (!current[tail]) {
+    throw new Error(`Field "${field}" not found in mappings`);
+  }
+
+  return current[tail];
+};
+const getFieldType = (context: QueryContext, field: string) => {
+  const definition = getFieldDefinition(context, field);
+  return definition.type;
+};
+
+const matchNested = (context: QueryContext, nested: { path: string; query: Filter }) => {
+  const nestedPath = nested.path;
+  const nestedDocuments = resolveField(context, nestedPath);
+
+  if (!Array.isArray(nestedDocuments)) {
+    throw new InvalidRequestError(`Nested path "${nestedPath}" is not an array`);
+  }
+
+  return nestedDocuments.some(nestedDocument => matchClause({
+    ...context,
+    scope: nestedPath,
+    document: nestedDocument
+  }, nested.query));
+};
+const matchExists = (context: QueryContext, exists: { field: string }) => {
+  const value = resolveField(context, exists.field);
+  return value !== undefined && value !== null;
+};
+const matchTerms = (context: QueryContext, terms: Record<string, FieldType>) => {
+
+  for (const key in terms) {
+    const docValues = coerceArray(resolveField(context, key));
+    const coerceValue = getFieldType(context, key) === 'boolean'
+      ? (input: string | boolean | number) => {
+        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');
+      }
+      : <T>(x: T) => x;
+    const hasMatch = coerceArray(terms[key]).map(coerceValue).some(v => docValues.includes(v));
+
+    if (!hasMatch) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const matchClause = (context: QueryContext, clause: Filter): boolean => {
+  const filter = ('key' in clause && 'value' in clause)
+    ? {terms: {[clause.key]: clause.value}}
+    : clause;
+
+  if ('terms' in filter) return matchTerms(context, filter.terms);
+  else if ('term' in filter) return matchTerms(context, filter.term);
+  else if ('exists' in filter) return matchExists(context, filter.exists);
+  else if ('bool' in filter) return matchBool(context, filter.bool);
+  else if ('nested' in filter) return matchNested(context, filter.nested);
+  else throw new InvalidRequestError('invalid filter type');
+};
+
+const matchFilters = (context: QueryContext, filters: Filter[], matchType: MatchType) => {
+  for (const field of filters) {
+    const hasMatch = matchClause(context, field);
+
+    if ((matchType === MatchType.Must && !hasMatch) || (matchType === MatchType.MustNot && hasMatch)) {
+      return false;
+    } else if (matchType === MatchType.Should && hasMatch) {
+      return true;
+    }
+  }
+
+  return matchType !== MatchType.Should;
+};
+
+const matchBool = (context: QueryContext, filters: BoolFilter) => {
+  const { must_not, should, must, filter } = filters;
+  if (must?.length && !matchFilters(context, must, MatchType.Must)) {
+    return false;
+  }
+  if (filter?.length && !matchFilters(context, filter, MatchType.Must)) {
+    return false;
+  }
+  if (must_not?.length && !matchFilters(context, must_not, MatchType.MustNot)) {
+    return false;
+  }
+  if (should?.length && !matchFilters(context, should, MatchType.Should)) {
+    return false;
+  }
+
+  return true;
+};
+
+export type Config<T> = {
+  mappings: FieldMappings;
+  store: {loadAllDocumentsTheBadWay: () => Promise<T[]>};
+};
+
+export const memorySearchTheBadWay = () => <T>({store, mappings}: Config<T>) => {
+  return {
+    // This method is intentionally stubbed because index deletion is not applicable for in-memory storage.
+    deleteIndexIfExists: async() => undefined,
+    ensureIndexCreated: async() => undefined,
+    index: async(_options: IndexOptions<T>) => undefined,
+    bulkIndex: async(_items: IndexOptions<T>[]) => undefined,
+    search: async(options: SearchOptions) => {
+
+      const results = (await store.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, fields: mappings, scope: ''}, field.key);
+
+              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()}`);
+              }
+            }
+          }
+
+          if (!matchBool({document, fields: mappings, scope: ''}, options)) {
+            return undefined;
+          }
+
+          return {document, weight};
+        })
+        .filter(isDefined)
+        .filter(r => !options.query || r.weight >= MIN_MATCH)
+      ;
+
+      results.sort((a, b) => {
+        for (const sort of (options.sort || [])) {
+          const aValue = resolveField({document: a.document, fields: mappings, scope: ''}, sort.key);
+          const bValue = resolveField({document: b.document, fields: mappings, scope: ''}, sort.key);
+
+          if (aValue < bValue) {
+            return sort.order === 'asc' ? -1 : 1;
+          }
+          if (aValue > bValue) {
+            return sort.order === 'asc' ? 1 : -1;
+          }
+        }
+
+        return 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)
+      };
+    },
+  };
+};