habsi/elasticsearch-js
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Minor fixes

Browse Source
This commit is contained in:
delvedor
2020-09-10 15:09:11 +02:00
parent c2b485f53a
commit 98dafc0b63
2 changed files with 59 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
dsl/src/fluent.ts
View File

@ -30,6 +30,7 @@ import * as t from './types'
import T from '../es-types' import T from '../es-types'
const kState = Symbol('dsl-query-state') const kState = Symbol('dsl-query-state')
type MultiType = string | number | boolean
// TODO: the client should detect a fluent query // TODO: the client should detect a fluent query
// and automatically call `query.build()` // and automatically call `query.build()`
@ -56,10 +57,10 @@ class FluentQ {
return Q.compile(this.build()) return Q.compile(this.build())
} }
match (key: string, val: string | Symbol): this match (key: string, val: MultiType | Symbol): this
match (key: string, val: string | Symbol, opts: T.MatchQuery): this match (key: string, val: MultiType | Symbol, opts: T.MatchQuery): this
match (key: string, val: (string | Symbol)[]): this match (key: string, val: (MultiType | Symbol)[]): this
match (key: string, val: (string | Symbol)[], opts: T.MatchQuery): this match (key: string, val: (MultiType | Symbol)[], opts: T.MatchQuery): this
match (key: string, val: any, opts?: any): this { match (key: string, val: any, opts?: any): this {
this[kState].push(Q.match(key, val, opts)) this[kState].push(Q.match(key, val, opts))
return this return this
@ -117,10 +118,10 @@ class FluentQ {
return this return this
} }
term (key: string, val: string | Symbol): this term (key: string, val: MultiType | Symbol): this
term (key: string, val: string | Symbol, opts: T.TermQuery): this term (key: string, val: MultiType | Symbol, opts: T.TermQuery): this
term (key: string, val: (string | Symbol)[]): this term (key: string, val: (MultiType | Symbol)[]): this
term (key: string, val: (string | Symbol)[], opts: T.TermsQuery): this term (key: string, val: (MultiType | Symbol)[], opts: T.TermsQuery): this
term (key: string, val: any, opts?: any): this { term (key: string, val: any, opts?: any): this {
if (Array.isArray(val)) { if (Array.isArray(val)) {
return this.terms(key, val, opts) return this.terms(key, val, opts)
@ -129,7 +130,7 @@ class FluentQ {
return this return this
} }
terms (key: string, val: string[] | Symbol, opts?: T.TermsQuery): this { terms (key: string, val: (MultiType | Symbol)[], opts?: T.TermsQuery): this {
this[kState].push(Q.terms(key, val, opts)) this[kState].push(Q.terms(key, val, opts))
return this return this
} }

87
dsl/src/query.ts
View File

@ -26,11 +26,21 @@
import * as t from './types' import * as t from './types'
import T from '../es-types' import T from '../es-types'
interface BoolQuery {
filter?: T.QueryContainer[]
minimum_should_match?: T.MinimumShouldMatch
must?: T.QueryContainer[]
must_not?: T.QueryContainer[]
should?: T.QueryContainer[]
_name?: string
}
type SearchRequest = Required<T.SearchRequest>['body'] type SearchRequest = Required<T.SearchRequest>['body']
type BoolBlock = { bool: T.BoolQuery } type BoolBlock = { bool: BoolQuery }
type QueryBlock = { query: T.QueryContainer } type QueryBlock = { query: T.QueryContainer }
function Q (...blocks: (SearchRequest | T.QueryContainer | T.QueryContainer[])[]): SearchRequest { type MultiType = string | number | boolean
blocks = blocks.flat()
function Q (...blocks: (SearchRequest | T.QueryContainer | T.QueryContainer[] | BoolQuery)[]): SearchRequest {
blocks = blocks.flat() as (SearchRequest | T.QueryContainer | BoolQuery)[]
const topLevelKeys = [ const topLevelKeys = [
'aggs', 'aggs',
'collapse', 'collapse',
@ -55,8 +65,8 @@ function Q (...blocks: (SearchRequest | T.QueryContainer | T.QueryContainer[])[]
'version' 'version'
] ]
// @ts-ignore // @ts-expect-error
const queries: (T.QueryContainer | T.BoolQuery)[] = blocks.filter(block => !topLevelKeys.includes(Object.keys(block)[0])) const queries: (T.QueryContainer | BoolQuery)[] = blocks.filter(block => !topLevelKeys.includes(Object.keys(block)[0]))
let body: SearchRequest let body: SearchRequest
if (queries.length === 1 && !isBoolQuery(queries[0])) { if (queries.length === 1 && !isBoolQuery(queries[0])) {
@ -211,10 +221,10 @@ namespace Q {
} }
} }
export function match (key: string, val: string | Symbol): { match: Record<string, string> } export function match (key: string, val: MultiType | Symbol): { match: Record<string, MultiType> }
export function match (key: string, val: string | Symbol, opts: T.MatchQuery): { match: Record<string, T.MatchQuery> } export function match (key: string, val: MultiType | Symbol, opts: T.MatchQuery): { match: Record<string, T.MatchQuery> }
export function match (key: string, val: (string | Symbol)[]): { match: Record<string, string> }[] export function match (key: string, val: (MultiType | Symbol)[]): { match: Record<string, MultiType> }[]
export function match (key: string, val: (string | Symbol)[], opts: T.MatchQuery): { match: Record<string, T.MatchQuery> }[] export function match (key: string, val: (MultiType | Symbol)[], opts: T.MatchQuery): { match: Record<string, T.MatchQuery> }[]
export function match (key: string, val: any, opts?: T.MatchQuery): any { export function match (key: string, val: any, opts?: T.MatchQuery): any {
return generateQueryObject('match', key, val, opts) return generateQueryObject('match', key, val, opts)
} }
@ -282,10 +292,10 @@ namespace Q {
} }
} }
export function term (key: string, val: string | Symbol): { term: Record<string, string> } export function term (key: string, val: MultiType | Symbol): { term: Record<string, MultiType> }
export function term (key: string, val: string | Symbol, opts: T.TermQuery): { term: Record<string, T.TermQuery> } export function term (key: string, val: MultiType | Symbol, opts: T.TermQuery): { term: Record<string, T.TermQuery> }
export function term (key: string, val: (string | Symbol)[]): { terms: T.TermsQuery } export function term (key: string, val: (MultiType | Symbol)[]): { terms: T.TermsQuery }
export function term (key: string, val: (string | Symbol)[], opts: T.TermsQuery): { terms: T.TermsQuery } export function term (key: string, val: (MultiType | Symbol)[], opts: T.TermsQuery): { terms: T.TermsQuery }
export function term (key: string, val: any, opts?: any): any { export function term (key: string, val: any, opts?: any): any {
if (Array.isArray(val)) { if (Array.isArray(val)) {
return Q.terms(key, val, opts) return Q.terms(key, val, opts)
@ -293,7 +303,7 @@ namespace Q {
return generateValueObject('term', key, val, opts) return generateValueObject('term', key, val, opts)
} }
export function terms (key: string, val: string[] | Symbol, opts?: T.TermsQuery): { terms: T.TermsQuery } { export function terms (key: string, val: (MultiType | Symbol)[], opts?: T.TermsQuery): { terms: T.TermsQuery } {
return { return {
terms: { terms: {
[key]: val, [key]: val,
@ -370,8 +380,8 @@ namespace Q {
} }
} }
type AnyQueryWithArray = T.QueryContainer | T.BoolQuery | T.QueryContainer[] | T.BoolQuery[] type AnyQueryWithArray = T.QueryContainer | BoolQuery | T.QueryContainer[] | BoolQuery[]
type AnyQuery = T.QueryContainer | T.BoolQuery type AnyQuery = T.QueryContainer | BoolQuery
export function must (...queries: AnyQueryWithArray[]): { must: T.QueryContainer[] } { export function must (...queries: AnyQueryWithArray[]): { must: T.QueryContainer[] } {
// @ts-ignore // @ts-ignore
return { must: queries.flatMap(mergeableMust) } return { must: queries.flatMap(mergeableMust) }
@ -392,14 +402,14 @@ namespace Q {
return { filter: queries.flatMap(mergeableFilter) } return { filter: queries.flatMap(mergeableFilter) }
} }
export function bool (...queries: (T.QueryContainer | T.QueryContainer[] | T.BoolQuery)[]): BoolBlock { export function bool (...queries: (T.QueryContainer | T.QueryContainer[] | BoolQuery)[]): BoolBlock {
if (queries.length === 0) { if (queries.length === 0) {
return { bool: {} } return { bool: {} }
} }
// @ts-expect-error // @ts-expect-error
const defaultClause = queries.find(q => q && !!q.minimum_should_match) ? 'should' : 'must' const defaultClause = queries.find(q => q && !!q.minimum_should_match) ? 'should' : 'must'
const normalizedQueries = queries const normalizedQueries: BoolQuery[] = queries
.flat() .flat()
.filter(val => { .filter(val => {
// filters empty objects/arrays as well // filters empty objects/arrays as well
@ -504,7 +514,7 @@ namespace Q {
} }
export function not (q: T.QueryContainer): BoolBlock export function not (q: T.QueryContainer): BoolBlock
export function not (q: T.BoolQuery): BoolBlock export function not (q: BoolQuery): BoolBlock
export function not (q: any): BoolBlock { export function not (q: any): BoolBlock {
const b = toBoolQuery(q) const b = toBoolQuery(q)
@ -523,11 +533,11 @@ namespace Q {
} }
} }
export function minShouldMatch (int: number): T.BoolQuery { export function minShouldMatch (int: number): BoolQuery {
return { minimum_should_match: int } return { minimum_should_match: int }
} }
export function name (queryName: string): T.BoolQuery { export function name (queryName: string): BoolQuery {
return { _name: queryName } return { _name: queryName }
} }
@ -577,13 +587,14 @@ namespace Q {
} }
} }
export function size (s: number | Symbol): { size: number | Symbol } { export function size (s: number | Symbol): { size: number } {
// @ts-expect-error
return { size: s } return { size: s }
} }
} }
// Tries to flat a bool query based on the content // Tries to flat a bool query based on the content
function booptimize (q: T.BoolQuery): T.BoolQuery { function booptimize (q: BoolQuery): BoolQuery {
const clauses: t.BoolQueryOptions = {} const clauses: t.BoolQueryOptions = {}
if (q.minimum_should_match !== undefined || if (q.minimum_should_match !== undefined ||
@ -724,7 +735,7 @@ function isBoolBlock (q: any): q is BoolBlock {
return !!q.bool return !!q.bool
} }
function isBoolQuery (q: any): q is T.BoolQuery { function isBoolQuery (q: any): q is BoolQuery {
if (q.must !== undefined) return true if (q.must !== undefined) return true
if (q.should !== undefined) return true if (q.should !== undefined) return true
if (q.must_not !== undefined) return true if (q.must_not !== undefined) return true
@ -734,7 +745,7 @@ function isBoolQuery (q: any): q is T.BoolQuery {
return false return false
} }
function onlyShould (bool: T.BoolQuery): bool is t.ShouldClause { function onlyShould (bool: BoolQuery): bool is t.ShouldClause {
if (bool.must !== undefined) return false if (bool.must !== undefined) return false
if (bool.must_not !== undefined) return false if (bool.must_not !== undefined) return false
if (bool.filter !== undefined) return false if (bool.filter !== undefined) return false
@ -743,7 +754,7 @@ function onlyShould (bool: T.BoolQuery): bool is t.ShouldClause {
return true return true
} }
function onlyMust (bool: T.BoolQuery): bool is t.MustClause { function onlyMust (bool: BoolQuery): bool is t.MustClause {
if (bool.should !== undefined) return false if (bool.should !== undefined) return false
if (bool.must_not !== undefined) return false if (bool.must_not !== undefined) return false
if (bool.filter !== undefined) return false if (bool.filter !== undefined) return false
@ -752,7 +763,7 @@ function onlyMust (bool: T.BoolQuery): bool is t.MustClause {
return true return true
} }
function onlyMustNot (bool: T.BoolQuery): bool is t.MustNotClause { function onlyMustNot (bool: BoolQuery): bool is t.MustNotClause {
if (bool.should !== undefined) return false if (bool.should !== undefined) return false
if (bool.must !== undefined) return false if (bool.must !== undefined) return false
if (bool.filter !== undefined) return false if (bool.filter !== undefined) return false
@ -761,7 +772,7 @@ function onlyMustNot (bool: T.BoolQuery): bool is t.MustNotClause {
return true return true
} }
function onlyFilter (bool: T.BoolQuery): bool is t.FilterClause { function onlyFilter (bool: BoolQuery): bool is t.FilterClause {
if (bool.should !== undefined) return false if (bool.should !== undefined) return false
if (bool.must !== undefined) return false if (bool.must !== undefined) return false
if (bool.must_not !== undefined) return false if (bool.must_not !== undefined) return false
@ -774,7 +785,7 @@ function onlyFilter (bool: T.BoolQuery): bool is t.FilterClause {
// - if is a bool query returns the bool block // - if is a bool query returns the bool block
// - if is a clause, wraps the query in a bool block // - if is a clause, wraps the query in a bool block
// - if is condition, wraps the query into a must clause and then in a bool block // - if is condition, wraps the query into a must clause and then in a bool block
function toBoolBlock (query: T.QueryContainer | T.BoolQuery): BoolBlock { function toBoolBlock (query: T.QueryContainer | BoolQuery): BoolBlock {
if (isBoolQuery(query)) { if (isBoolQuery(query)) {
return { bool: query } return { bool: query }
} }
@ -791,7 +802,7 @@ function toBoolBlock (query: T.QueryContainer | T.BoolQuery): BoolBlock {
// - if is a clause, it returns it // - if is a clause, it returns it
// - if is condition, wraps the query into a must clause and returns it // - if is condition, wraps the query into a must clause and returns it
type toBoolQueryDefault = 'must' | 'must_not' | 'should' | 'filter' type toBoolQueryDefault = 'must' | 'must_not' | 'should' | 'filter'
function toBoolQuery (query: T.QueryContainer | T.BoolQuery, def: toBoolQueryDefault = 'must'): T.BoolQuery { function toBoolQuery (query: T.QueryContainer | BoolQuery, def: toBoolQueryDefault = 'must'): BoolQuery {
if (isBoolQuery(query)) { if (isBoolQuery(query)) {
return query return query
} }
@ -811,8 +822,8 @@ function toBoolQuery (query: T.QueryContainer | T.BoolQuery, def: toBoolQueryDef
// the aim of this mergeable functions // the aim of this mergeable functions
// is to reduce the depth of the query objects // is to reduce the depth of the query objects
function mergeableMust (q: T.QueryContainer | T.BoolQuery): T.QueryContainer function mergeableMust (q: T.QueryContainer | BoolQuery): T.QueryContainer
function mergeableMust (q: (T.QueryContainer | T.BoolQuery)[]): T.QueryContainer[] function mergeableMust (q: (T.QueryContainer | BoolQuery)[]): T.QueryContainer[]
function mergeableMust (q: any): any { function mergeableMust (q: any): any {
if (Array.isArray(q)) { if (Array.isArray(q)) {
return q.map(mergeableMust) return q.map(mergeableMust)
@ -834,8 +845,8 @@ function mergeableMust (q: any): any {
} }
} }
function mergeableShould (q: T.QueryContainer | T.BoolQuery): T.QueryContainer function mergeableShould (q: T.QueryContainer | BoolQuery): T.QueryContainer
function mergeableShould (q: (T.QueryContainer | T.BoolQuery)[]): T.QueryContainer[] function mergeableShould (q: (T.QueryContainer | BoolQuery)[]): T.QueryContainer[]
function mergeableShould (q: any): any { function mergeableShould (q: any): any {
if (Array.isArray(q)) { if (Array.isArray(q)) {
return q.map(mergeableShould) return q.map(mergeableShould)
@ -857,8 +868,8 @@ function mergeableShould (q: any): any {
} }
} }
function mergeableMustNot (q: T.QueryContainer | T.BoolQuery): T.QueryContainer function mergeableMustNot (q: T.QueryContainer | BoolQuery): T.QueryContainer
function mergeableMustNot (q: (T.QueryContainer | T.BoolQuery)[]): T.QueryContainer[] function mergeableMustNot (q: (T.QueryContainer | BoolQuery)[]): T.QueryContainer[]
function mergeableMustNot (q: any): any { function mergeableMustNot (q: any): any {
if (Array.isArray(q)) { if (Array.isArray(q)) {
return q.map(mergeableMustNot) return q.map(mergeableMustNot)
@ -881,8 +892,8 @@ function mergeableMustNot (q: any): any {
} }
} }
function mergeableFilter (q: T.QueryContainer | T.BoolQuery): T.QueryContainer function mergeableFilter (q: T.QueryContainer | BoolQuery): T.QueryContainer
function mergeableFilter (q: (T.QueryContainer | T.BoolQuery)[]): T.QueryContainer[] function mergeableFilter (q: (T.QueryContainer | BoolQuery)[]): T.QueryContainer[]
function mergeableFilter (q: any): any { function mergeableFilter (q: any): any {
if (Array.isArray(q)) { if (Array.isArray(q)) {
return q.map(mergeableFilter) return q.map(mergeableFilter)