Support for Elasticsearch 7.7 (#1192)

test/types/helpers.test-d.ts

@@ -0,0 +1,432 @@
+// 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 {
+  BulkHelper,
+  BulkStats,
+  BulkHelperOptions,
+  ScrollSearchResponse,
+  OnDropDocument
+} from '../../lib/Helpers'
+
+const client = new Client({
+  node: 'http://localhost:9200'
+})
+
+/// .helpers.bulk
+
+const b = client.helpers.bulk<Record<string, any>>({
+  datasource: [],
+  onDocument (doc) {
+    expectType<Record<string, any>>(doc)
+    return { index: { _index: 'test' } }
+  },
+  flushBytes: 5000000,
+  concurrency: 5,
+  retries: 3,
+  wait: 5000,
+  onDrop (doc) {
+    expectType<OnDropDocument<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<Record<string, any>>>(options)
+}
+// create
+{
+  const options = {
+    datasource: [],
+    onDocument (doc: Record<string, any>) {
+      return { create: { _index: 'test' } }
+    }
+  }
+  expectAssignable<BulkHelperOptions<Record<string, any>>>(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<Record<string, any>> = {
+    datasource: [],
+    onDocument (doc: Record<string, any>) {
+      return [{ update: { _index: 'test' } }, doc]
+    }
+  }
+  expectAssignable<BulkHelperOptions<Record<string, any>>>(options)
+}
+// delete
+{
+  const options = {
+    datasource: [],
+    onDocument (doc: Record<string, any>) {
+      return { delete: { _index: 'test' } }
+    }
+  }
+  expectAssignable<BulkHelperOptions<Record<string, any>>>(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<Record<string, any>>(response.body)
+      expectType<unknown[]>(response.documents)
+      expectType<unknown>(response.meta.context)
+    }
+  }
+}
+
+// with type defs
+{  
+  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<Source, SearchResponse<Source>>({
+      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<unknown>(response.meta.context)
+    }
+  }
+}
+
+{
+  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<Source, SearchResponse<Source>, SearchBody, 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 Source {
+    foo: string
+  }
+
+  async function test () {
+    const scrollDocuments = client.helpers.scrollDocuments<Source>({
+      index: 'test',
+      body: {
+        query: {
+          match: { foo: 'bar' }
+        }
+      }
+    })
+
+    for await (const document of scrollDocuments) {
+      expectType<Source>(document)
+    }
+  }
+}
+
+{
+  interface SearchBody {
+    query: {
+      match: { foo: string }
+    }
+  }
+  
+  interface Source {
+    foo: string
+  }
+
+  async function test () {
+    const scrollDocuments = client.helpers.scrollDocuments<Source, SearchBody>({
+      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 Source {
+    foo: string
+  }
+
+  const p = client.helpers.search<Source>({
+    index: 'test',
+    body: {
+      query: {
+        match: { foo: 'bar' }
+      }
+    }
+  })
+
+  expectType<Promise<Source[]>>(p)
+  expectType<Source[]>(await p)
+}
+
+{
+  interface SearchBody {
+    query: {
+      match: { foo: string }
+    }
+  }
+  
+  interface Source {
+    foo: string
+  }
+
+  const p = client.helpers.search<Source, SearchBody>({
+    index: 'test',
+    body: {
+      query: {
+        match: { foo: 'bar' }
+      }
+    }
+  })
+
+  expectType<Promise<Source[]>>(p)
+  expectType<Source[]>(await p)
+}