@openstax/ts-utils 1.21.9 → 1.21.11

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

@@ -1,31 +0,0 @@
-export declare type Filter = {
-    key: string;
-    value: string | string[] | boolean;
-};
-declare type Field = {
-    key: string;
-    type?: 'text';
-    weight: number;
-} | {
-    key: string;
-    type: 'keyword';
-} | {
-    key: string;
-    type: 'boolean';
-};
-export interface IndexOptions<T> {
-    body: T;
-    id: string;
-}
-export interface SearchOptions {
-    page?: number;
-    query: string | undefined;
-    fields: Field[];
-    /**
-     * @deprecated use `must` instead
-     */
-    filter?: Filter[];
-    must?: Filter[];
-    must_not?: Filter[];
-}
-export {};

package/dist/cjs/services/searchProvider/index.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,14 +0,0 @@
-import { IndexOptions, SearchOptions } from '.';
-export declare const memorySearchTheBadWay: <T>({ loadAllDocumentsTheBadWay }: {
-    loadAllDocumentsTheBadWay: () => Promise<T[]>;
-}) => {
-    ensureIndexCreated: () => Promise<undefined>;
-    index: (_options: IndexOptions<T>) => Promise<undefined>;
-    search: (options: SearchOptions) => Promise<{
-        items: T[];
-        pageSize: number;
-        currentPage: number;
-        totalItems: number;
-        totalPages: number;
-    }>;
-};

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

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.memorySearchTheBadWay = void 0;
-const __1 = require("../..");
-const errors_1 = require("../../errors");
-const guards_1 = require("../../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);
-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 = (0, __1.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 errors_1.InvalidRequestError('input is not a valid boolean filter');
-                            }
-                            : (x) => x;
-                        const hasMatch = (0, __1.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(guards_1.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)
-            };
-        },
-    };
-};
-exports.memorySearchTheBadWay = memorySearchTheBadWay;