@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/search-index/elastic/query-converter.js

@@ -1,183 +1,201 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { hasOwnProperty, objectEntries, objectValues } from '../../utils/object/object.js';
-import { assertDefinedPass, isPrimitive, isRegExp, isString } from '../../utils/type-guards.js';
-import { BoolQueryBuilder } from './query-builder/index.js';
-// eslint-disable-next-line max-lines-per-function, max-statements, complexity
-export function convertQuery(query) {
-    const defaultBoolQueryBuilder = new BoolQueryBuilder();
-    const queryEntries = objectEntries(query);
-    // eslint-disable-next-line no-unreachable-loop
-    for (const [rawProperty, value] of queryEntries) {
-        const property = getPropertyName(rawProperty);
-        const isPrimitiveValue = isPrimitive(value);
-        const range = {};
-        let canHandleProperty = false;
-        if (rawProperty == '$and') {
-            if (queryEntries.length > 1) {
-                throw new Error('only one logical operator per level allowed');
-            }
-            return convertLogicalAndQuery(value);
-        }
-        if (rawProperty == '$or') {
-            if (queryEntries.length > 1) {
-                throw new Error('only one logical operator per level allowed');
-            }
-            return convertLogicalOrQuery(value);
-        }
-        if (rawProperty == '$nor') {
-            if (queryEntries.length > 1) {
-                throw new Error('only one logical operator per level allowed');
-            }
-            return convertLogicalNorQuery(value);
-        }
-        if (rawProperty == '$textSpan') {
-            const { fields, text, mode, operator } = value;
-            const type = convertTextSpanQueryMode(mode);
-            const matchQuery = { multi_match: { fields, query: text, type, operator } };
-            defaultBoolQueryBuilder.must(matchQuery);
-            canHandleProperty = true;
-        }
-        if (isPrimitiveValue || hasOwnProperty(value, '$eq')) {
-            const termQuery = {
-                term: { [property]: isPrimitiveValue ? value : value.$eq }
-            };
-            defaultBoolQueryBuilder.must(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$neq')) {
-            const termQuery = {
-                term: { [property]: value.$neq }
-            };
-            defaultBoolQueryBuilder.mustNot(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$exists')) {
-            const existsQuery = { exists: { field: property } };
-            if (value.$exists) {
-                defaultBoolQueryBuilder.must(existsQuery);
-            }
-            else {
-                defaultBoolQueryBuilder.mustNot(existsQuery);
-            }
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$in')) {
-            const termQuery = {
-                terms: { [property]: value.$in }
-            };
-            defaultBoolQueryBuilder.must(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$nin')) {
-            const termQuery = {
-                terms: { [property]: value.$nin }
-            };
-            defaultBoolQueryBuilder.mustNot(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$lt')) {
-            range.lt = value.$lt;
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$lte')) {
-            range.lte = value.$lte;
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$gt')) {
-            range.gt = value.$gt;
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$gte')) {
-            range.gte = value.$gte;
-            canHandleProperty = true;
-        }
-        if (objectValues(range).length > 0) {
-            const rangeQuery = { range: { [property]: range } };
-            defaultBoolQueryBuilder.must(rangeQuery);
-        }
-        if (hasOwnProperty(value, '$regex')) {
-            const regex = value.$regex;
-            const regexp = isString(regex)
-                ? regex
-                : isRegExp(regex)
-                    ? { flags: regex.flags, value: regex.source }
-                    : { flags: regex.flags, value: regex.pattern };
-            const termQuery = {
-                regexp: { property: regexp }
-            };
-            defaultBoolQueryBuilder.must(termQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$text')) {
-            let matchQuery;
-            const textQueryValue = value.$text;
-            if (typeof textQueryValue == 'string') {
-                matchQuery = { match: { [property]: { query: textQueryValue } } };
-            }
-            else {
-                matchQuery = { match: { [property]: { query: textQueryValue.text, operator: textQueryValue.operator } } };
-            }
-            defaultBoolQueryBuilder.must(matchQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$geoShape')) {
-            const geoShapeQuery = {
-                geo_shape: {
-                    [property]: {
-                        shape: value.$geoShape.geometry,
-                        relation: value.$geoShape.relation
-                    }
-                }
-            };
-            defaultBoolQueryBuilder.must(geoShapeQuery);
-            canHandleProperty = true;
-        }
-        if (hasOwnProperty(value, '$geoDistance')) {
-            const distance = assertDefinedPass(value.$geoDistance.maxDistance, 'maxDistance required');
-            const geoShapeQuery = {
-                geo_distance: {
-                    distance: `${distance}m`,
-                    [property]: [
-                        value.$geoDistance.longitude,
-                        value.$geoDistance.latitude
-                    ]
-                }
-            };
-            defaultBoolQueryBuilder.must(geoShapeQuery);
-            canHandleProperty = true;
-        }
-        if (!canHandleProperty) {
-            throw new Error(`unsupported query type "${rawProperty}"`);
-        }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var query_converter_exports = {};
+__export(query_converter_exports, {
+  convertLogicalAndQuery: () => convertLogicalAndQuery,
+  convertLogicalNorQuery: () => convertLogicalNorQuery,
+  convertLogicalOrQuery: () => convertLogicalOrQuery,
+  convertQuery: () => convertQuery,
+  convertTextSpanQueryMode: () => convertTextSpanQueryMode
+});
+module.exports = __toCommonJS(query_converter_exports);
+var import_object = require("../../utils/object/object.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var import_query_builder = require("./query-builder/index.js");
+function convertQuery(query) {
+  const defaultBoolQueryBuilder = new import_query_builder.BoolQueryBuilder();
+  const queryEntries = (0, import_object.objectEntries)(query);
+  for (const [rawProperty, value] of queryEntries) {
+    const property = getPropertyName(rawProperty);
+    const isPrimitiveValue = (0, import_type_guards.isPrimitive)(value);
+    const range = {};
+    let canHandleProperty = false;
+    if (rawProperty == "$and") {
+      if (queryEntries.length > 1) {
+        throw new Error("only one logical operator per level allowed");
+      }
+      return convertLogicalAndQuery(value);
     }
-    if (defaultBoolQueryBuilder.totalQueries == 0) {
-        return { match_all: {} };
+    if (rawProperty == "$or") {
+      if (queryEntries.length > 1) {
+        throw new Error("only one logical operator per level allowed");
+      }
+      return convertLogicalOrQuery(value);
     }
-    return defaultBoolQueryBuilder.build();
+    if (rawProperty == "$nor") {
+      if (queryEntries.length > 1) {
+        throw new Error("only one logical operator per level allowed");
+      }
+      return convertLogicalNorQuery(value);
+    }
+    if (rawProperty == "$textSpan") {
+      const { fields, text, mode, operator } = value;
+      const type = convertTextSpanQueryMode(mode);
+      const matchQuery = { multi_match: { fields, query: text, type, operator } };
+      defaultBoolQueryBuilder.must(matchQuery);
+      canHandleProperty = true;
+    }
+    if (isPrimitiveValue || (0, import_object.hasOwnProperty)(value, "$eq")) {
+      const termQuery = {
+        term: { [property]: isPrimitiveValue ? value : value.$eq }
+      };
+      defaultBoolQueryBuilder.must(termQuery);
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$neq")) {
+      const termQuery = {
+        term: { [property]: value.$neq }
+      };
+      defaultBoolQueryBuilder.mustNot(termQuery);
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$exists")) {
+      const existsQuery = { exists: { field: property } };
+      if (value.$exists) {
+        defaultBoolQueryBuilder.must(existsQuery);
+      } else {
+        defaultBoolQueryBuilder.mustNot(existsQuery);
+      }
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$in")) {
+      const termQuery = {
+        terms: { [property]: value.$in }
+      };
+      defaultBoolQueryBuilder.must(termQuery);
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$nin")) {
+      const termQuery = {
+        terms: { [property]: value.$nin }
+      };
+      defaultBoolQueryBuilder.mustNot(termQuery);
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$lt")) {
+      range.lt = value.$lt;
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$lte")) {
+      range.lte = value.$lte;
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$gt")) {
+      range.gt = value.$gt;
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$gte")) {
+      range.gte = value.$gte;
+      canHandleProperty = true;
+    }
+    if ((0, import_object.objectValues)(range).length > 0) {
+      const rangeQuery = { range: { [property]: range } };
+      defaultBoolQueryBuilder.must(rangeQuery);
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$regex")) {
+      const regex = value.$regex;
+      const regexp = (0, import_type_guards.isString)(regex) ? regex : (0, import_type_guards.isRegExp)(regex) ? { flags: regex.flags, value: regex.source } : { flags: regex.flags, value: regex.pattern };
+      const termQuery = {
+        regexp: { property: regexp }
+      };
+      defaultBoolQueryBuilder.must(termQuery);
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$text")) {
+      let matchQuery;
+      const textQueryValue = value.$text;
+      if (typeof textQueryValue == "string") {
+        matchQuery = { match: { [property]: { query: textQueryValue } } };
+      } else {
+        matchQuery = { match: { [property]: { query: textQueryValue.text, operator: textQueryValue.operator } } };
+      }
+      defaultBoolQueryBuilder.must(matchQuery);
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$geoShape")) {
+      const geoShapeQuery = {
+        geo_shape: {
+          [property]: {
+            shape: value.$geoShape.geometry,
+            relation: value.$geoShape.relation
+          }
+        }
+      };
+      defaultBoolQueryBuilder.must(geoShapeQuery);
+      canHandleProperty = true;
+    }
+    if ((0, import_object.hasOwnProperty)(value, "$geoDistance")) {
+      const distance = (0, import_type_guards.assertDefinedPass)(value.$geoDistance.maxDistance, "maxDistance required");
+      const geoShapeQuery = {
+        geo_distance: {
+          distance: `${distance}m`,
+          [property]: [
+            value.$geoDistance.longitude,
+            value.$geoDistance.latitude
+          ]
+        }
+      };
+      defaultBoolQueryBuilder.must(geoShapeQuery);
+      canHandleProperty = true;
+    }
+    if (!canHandleProperty) {
+      throw new Error(`unsupported query type "${rawProperty}"`);
+    }
+  }
+  if (defaultBoolQueryBuilder.totalQueries == 0) {
+    return { match_all: {} };
+  }
+  return defaultBoolQueryBuilder.build();
 }
 function getPropertyName(property) {
-    return property == 'id' ? '_id' : property;
+  return property == "id" ? "_id" : property;
 }
-export function convertLogicalAndQuery(andQuery) {
-    return new BoolQueryBuilder().must(...andQuery.map(convertQuery)).build();
+function convertLogicalAndQuery(andQuery) {
+  return new import_query_builder.BoolQueryBuilder().must(...andQuery.map(convertQuery)).build();
 }
-export function convertLogicalOrQuery(orQuery) {
-    return new BoolQueryBuilder().should(...orQuery.map(convertQuery)).build();
+function convertLogicalOrQuery(orQuery) {
+  return new import_query_builder.BoolQueryBuilder().should(...orQuery.map(convertQuery)).build();
 }
-export function convertLogicalNorQuery(norQuery) {
-    return new BoolQueryBuilder().mustNot(...norQuery.map(convertQuery)).build();
+function convertLogicalNorQuery(norQuery) {
+  return new import_query_builder.BoolQueryBuilder().mustNot(...norQuery.map(convertQuery)).build();
 }
-export function convertTextSpanQueryMode(mode) {
-    switch (mode) {
-        case undefined:
-            return undefined;
-        case 'best':
-            return 'best_fields';
-        case 'most':
-            return 'most_fields';
-        case 'cross':
-            return 'cross_fields';
-        default:
-            throw new Error('unknown ComplexTextSpanQueryMode');
-    }
+function convertTextSpanQueryMode(mode) {
+  switch (mode) {
+    case void 0:
+      return void 0;
+    case "best":
+      return "best_fields";
+    case "most":
+      return "most_fields";
+    case "cross":
+      return "cross_fields";
+    default:
+      throw new Error("unknown ComplexTextSpanQueryMode");
+  }
 }

package/search-index/elastic/search-index.d.ts

@@ -1,6 +1,6 @@
-import type { AfterResolve } from '../../container/index.js';
-import { afterResolve } from '../../container/index.js';
 import type { Entity, Query, QueryOptions } from '../../database/index.js';
+import type { AfterResolve } from '../../injector/interfaces.js';
+import { afterResolve } from '../../injector/interfaces.js';
 import type { Logger } from '../../logger/index.js';
 import type { SearchResult } from '../../search-index/index.js';
 import { SearchIndex } from '../../search-index/index.js';