@openstax/ts-utils 1.34.0 → 1.35.0

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

@@ -1,223 +0,0 @@
-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)
-      };
-    },
-  };
-};