@openstax/ts-utils 1.1.19 → 1.1.21

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { UnionToIntersection } from './types';
 export declare const getKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O) => O[K];
 export declare const getKeyValueOr: <K extends string, V, Od extends { [key in K]?: any; } = { [key_1 in K]?: any; }>(key: K, defaultValue: V) => <O extends Od extends undefined ? { [key_2 in K]?: any; } : Od>(obj: O) => V | NonNullable<O[K]>;
 export declare const putKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O, value: O[K]) => O;
+export declare const coerceArray: <T>(thing: T | T[] | undefined) => T[];
 declare type FlowFn<A, R> = (...args: [A]) => R;
 declare type AnyFlowFn = FlowFn<any, any>;
 declare type FlowFnResult<F, A> = F extends FlowFn<A, infer R> ? R : never;

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tuple = exports.merge = exports.getCommonProperties = exports.roundToPrecision = exports.memoize = exports.partitionSequence = exports.once = exports.hashValue = exports.mapFind = exports.fnIf = exports.flow = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
+exports.tuple = exports.merge = exports.getCommonProperties = exports.roundToPrecision = exports.memoize = exports.partitionSequence = exports.once = exports.hashValue = exports.mapFind = exports.fnIf = exports.flow = exports.coerceArray = exports.putKeyValue = exports.getKeyValueOr = exports.getKeyValue = void 0;
 const crypto_1 = require("crypto");
 const deep_equal_1 = __importDefault(require("deep-equal"));
 const guards_1 = require("./guards");
@@ -26,6 +26,8 @@ const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
 exports.getKeyValueOr = getKeyValueOr;
 const putKeyValue = (key) => (obj, value) => ({ ...obj, [key]: value });
 exports.putKeyValue = putKeyValue;
+const coerceArray = (thing) => thing instanceof Array ? thing : thing !== undefined ? [thing] : [];
+exports.coerceArray = coerceArray;
 /*
  * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
  */

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

@@ -1,25 +1,19 @@
-declare type KeysMatching<T, V> = {
-    [K in keyof T]-?: T[K] extends V ? K : never;
-}[keyof T];
-declare type UnArray<T> = T extends Array<infer I> ? I : T;
-declare type FilterFieldTypes = string | string[];
-declare type Filter<F extends keyof T, T> = F extends KeysMatching<T, FilterFieldTypes> ? {
-    key: F;
-    value: UnArray<T[F]> | UnArray<T[F]>[];
-} : never;
-declare type QueryFieldTypes = string | string[] | undefined | null;
-declare type Field<F extends keyof T, T> = F extends KeysMatching<T, QueryFieldTypes> ? ({
-    key: F;
+declare type Filter = {
+    key: string;
+    value: string | string[];
+};
+declare type Field = {
+    key: string;
     type?: 'text';
     weight: number;
 } | {
-    key: F;
+    key: string;
     type: 'keyword';
-}) : never;
-export interface SearchOptions<T> {
+};
+export interface SearchOptions {
     page?: number;
     query: string | undefined;
-    fields: Field<keyof T, T>[];
-    filter?: Filter<keyof T, T>[];
+    fields: Field[];
+    filter?: Filter[];
 }
 export {};

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

@@ -2,7 +2,7 @@ import { SearchOptions } from '.';
 export declare const memorySearchTheBadWay: <T>({ loadAllDocumentsTheBadWay }: {
     loadAllDocumentsTheBadWay: () => Promise<T[]>;
 }) => {
-    search: (options: SearchOptions<T>) => Promise<{
+    search: (options: SearchOptions) => Promise<{
         items: T[];
         pageSize: number;
         currentPage: number;

package/dist/services/searchProvider/memorySearchTheBadWay.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.memorySearchTheBadWay = void 0;
+const __1 = require("../..");
 const guards_1 = require("../../guards");
 const MIN_MATCH = 0.5;
 const MAX_RESULTS = 10;
+const resolveField = (document, field) => field.key.toString().split('.').reduce((result, key) => result[key], document);
 const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
     return {
         search: async (options) => {
@@ -15,12 +17,12 @@ const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                         if (field.type !== undefined && field.type !== 'text') {
                             continue;
                         }
-                        const value = document[field.key];
+                        const value = resolveField(document, field);
                         if (value === undefined || value === null) {
                             continue;
                         }
                         if (typeof value === 'string') {
-                            if (value.indexOf(options.query) !== -1) {
+                            if (value.toUpperCase().indexOf(options.query.toUpperCase()) !== -1) {
                                 weight += (1 * field.weight);
                             }
                         }
@@ -30,14 +32,8 @@ const memorySearchTheBadWay = ({ loadAllDocumentsTheBadWay }) => {
                     }
                 }
                 for (const field of options.filter || []) {
-                    const value = document[field.key];
-                    if (value instanceof Array) {
-                        if (!(field.value instanceof Array && field.value.some(v => value.includes(v)))
-                            && !(!(field.value instanceof Array) && value.includes(field.value))) {
-                            return undefined;
-                        }
-                    }
-                    else if (value !== field.value) {
+                    const value = resolveField(document, field);
+                    if (!(0, __1.coerceArray)(field.value).some(v => (0, __1.coerceArray)(value).includes(v))) {
                         return undefined;
                     }
                 }