Client helpers (#1107)

* Added client helpers

* Updated test

* The search helper should return only the documents

* Added code comments

* Fixed bug

* Updated test

* Removed bulkSize and added flushBytes

* Updated test

* Added concurrency

* Updated test

* Added support for 429 handling in the scroll search helper

* Updated test

* Updated stats count

* Updated test

* Fix test

* Use client maxRetries as default

* Updated type definitions

* Refactored bulk helper to be more consistent with the client api

* Updated test

* Improved error handling, added refreshOnCompletion option and forward additinal options to the bulk api

* Updated type definitions

* Updated test

* Fixed test on Node v8

* Updated test

* Added TODO

* Updated docs

* Added Node v8 note

* Updated scripts

* Removed useless files

* Added helpers to integration test

* Fix cli argument position

* Moar fixes

* Test run elasticsearch in github actions

* Use master action version

* Add vm.max_map_count step

* Test new action setup

* Added Configure sysctl limits step

* Updated action to latest version

* Don't run helpers integration test in jenkins

* Run helpers integratino test also with Node v10

* Updated docs

* Updated docs

* Updated helpers type definitions

* Added test for helpers type definitions

* Added license header
This commit is contained in:
Tomas Della Vedova
2020-03-23 17:43:10 +01:00
committed by GitHub
parent 6c82a4967e
commit d7836a16af
24 changed files with 7654 additions and 11 deletions

View File

@ -0,0 +1,330 @@
// Licensed to Elasticsearch B.V under one or more agreements.
// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
// See the LICENSE file in the project root for more information
import { expectType, expectError, expectAssignable } from 'tsd'
import { Client } from '../../'
import { RequestBody, ResponseBody } from '../../lib/Transport'
import {
BulkHelper,
BulkStats,
BulkHelperOptions,
ScrollSearchResponse
} from '../../lib/Helpers'
const client = new Client({
node: 'http://localhost:9200'
})
/// .helpers.bulk
const b = client.helpers.bulk({
datasource: [],
onDocument (doc) {
expectType<Record<string, any>>(doc)
return { index: { _index: 'test' } }
},
flushBytes: 5000000,
concurrency: 5,
retries: 3,
wait: 5000,
onDrop (doc) {
expectType<Record<string, any>>(doc)
},
refreshOnCompletion: true,
pipeline: 'my-pipeline'
})
expectType<BulkHelper<BulkStats>>(b)
expectType<BulkHelper<BulkStats>>(b.abort())
b.then(stats => expectType<BulkStats>(stats))
// body can't be provided
expectError(
client.helpers.bulk({
datasource: [],
onDocument (doc) {
return { index: { _index: 'test' } }
},
body: []
})
)
// test onDocument actions
// index
{
const options = {
datasource: [],
onDocument (doc: Record<string, any>) {
return { index: { _index: 'test' } }
}
}
expectAssignable<BulkHelperOptions>(options)
}
// create
{
const options = {
datasource: [],
onDocument (doc: Record<string, any>) {
return { create: { _index: 'test' } }
}
}
expectAssignable<BulkHelperOptions>(options)
}
// update
{
// without `:BulkHelperOptions` this test cannot pass
// but if we write these options inline inside
// a `.helper.bulk`, it works as expected
const options: BulkHelperOptions = {
datasource: [],
onDocument (doc: Record<string, any>) {
return [{ update: { _index: 'test' } }, doc]
}
}
expectAssignable<BulkHelperOptions>(options)
}
// delete
{
const options = {
datasource: [],
onDocument (doc: Record<string, any>) {
return { delete: { _index: 'test' } }
}
}
expectAssignable<BulkHelperOptions>(options)
}
/// .helpers.scrollSearch
// just search params
{
async function test () {
const scrollSearch = client.helpers.scrollSearch({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
})
for await (const response of scrollSearch) {
expectAssignable<ScrollSearchResponse>(response)
}
}
}
// search params and options
{
async function test () {
const scrollSearch = client.helpers.scrollSearch({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
}, { ignore: [404] })
for await (const response of scrollSearch) {
expectAssignable<ScrollSearchResponse>(response)
expectType<ResponseBody<Record<string, any>>>(response.body)
expectType<unknown[]>(response.documents)
expectType<unknown>(response.meta.context)
}
}
}
// with type defs
{
interface SearchBody {
query: {
match: { foo: string }
}
}
interface ShardsResponse {
total: number;
successful: number;
failed: number;
skipped: number;
}
interface Explanation {
value: number;
description: string;
details: Explanation[];
}
interface SearchResponse<T> {
took: number;
timed_out: boolean;
_scroll_id?: string;
_shards: ShardsResponse;
hits: {
total: number;
max_score: number;
hits: Array<{
_index: string;
_type: string;
_id: string;
_score: number;
_source: T;
_version?: number;
_explanation?: Explanation;
fields?: any;
highlight?: any;
inner_hits?: any;
matched_queries?: string[];
sort?: string[];
}>;
};
aggregations?: any;
}
interface Source {
foo: string
}
async function test () {
const scrollSearch = client.helpers.scrollSearch<SearchBody, Source, SearchResponse<Source>, string>({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
})
for await (const response of scrollSearch) {
expectAssignable<ScrollSearchResponse>(response)
expectType<SearchResponse<Source>>(response.body)
expectType<Source[]>(response.documents)
expectType<string>(response.meta.context)
}
}
}
/// .helpers.scrollDocuments
// just search params
{
async function test () {
const scrollDocuments = client.helpers.scrollDocuments({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
})
for await (const document of scrollDocuments) {
expectType<unknown>(document)
}
}
}
// search params and options
{
async function test () {
const scrollDocuments = client.helpers.scrollDocuments({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
}, { ignore: [404] })
for await (const document of scrollDocuments) {
expectType<unknown>(document)
}
}
}
// with type defs
{
interface SearchBody {
query: {
match: { foo: string }
}
}
interface Source {
foo: string
}
async function test () {
const scrollDocuments = client.helpers.scrollDocuments<SearchBody, Source>({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
})
for await (const document of scrollDocuments) {
expectType<Source>(document)
}
}
}
/// .helpers.search
// just search params
{
const p = client.helpers.search({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
})
expectType<Promise<unknown[]>>(p)
expectType<unknown[]>(await p)
}
// search params and options
{
const p = client.helpers.search({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
}, { ignore: [404] })
expectType<Promise<unknown[]>>(p)
expectType<unknown[]>(await p)
}
// with type defs
{
interface SearchBody {
query: {
match: { foo: string }
}
}
interface Source {
foo: string
}
const p = client.helpers.search<SearchBody, Source>({
index: 'test',
body: {
query: {
match: { foo: 'bar' }
}
}
})
expectType<Promise<Source[]>>(p)
expectType<Source[]>(await p)
}