New type definitions (#1358)

Author: delvedor

api/esapi.d.ts

@@ -28,7 +28,7 @@ export type ApiError = errors.ConfigurationError | errors.ConnectionError |
                        errors.NoLivingConnectionsError | errors.ResponseError |
                        errors.TimeoutError | errors.RequestAbortedError
 
-export type Context = Record<string, unknown> | null
+export type Context = unknown
 
 export interface nodeSelectorFn {
   (connections: Connection[]): Connection;

api/kibana.d.ts

@@ -30,7 +30,6 @@ const {
   generate,
   cloneAndCheckout,
   genFactory,
-  generateRequestTypes,
   generateDocs
 } = require('./utils')
 
@@ -47,10 +46,7 @@ function start (opts) {
   const packageFolder = join(__dirname, '..', 'api')
   const apiOutputFolder = join(packageFolder, 'api')
   const mainOutputFile = join(packageFolder, 'index.js')
-  const typeDefFile = join(__dirname, '..', 'index.d.ts')
-  const kibanaTypeDefFile = join(packageFolder, 'kibana.d.ts')
   const docOutputFile = join(__dirname, '..', 'docs', 'reference.asciidoc')
-  const requestParamsOutputFile = join(packageFolder, 'requestParams.d.ts')
 
   log.text = 'Cleaning API folder...'
   rimraf.sync(join(apiOutputFolder, '*.js'))
@@ -85,39 +81,13 @@ function start (opts) {
       writeFileSync(filePath, code, { encoding: 'utf8' })
     }
 
-    writeFileSync(
-      requestParamsOutputFile,
-      generateRequestTypes(opts.branch || opts.tag, allSpec),
-      { encoding: 'utf8' }
-    )
-
-    const { fn: factory, types, kibanaTypes } = genFactory(apiOutputFolder, [apiFolder, xPackFolder], namespaces)
+    const { fn: factory } = genFactory(apiOutputFolder, [apiFolder, xPackFolder], namespaces)
     writeFileSync(
       mainOutputFile,
       factory,
       { encoding: 'utf8' }
     )
 
-    let oldTypeDefString = readFileSync(typeDefFile, 'utf8')
-    let start = oldTypeDefString.indexOf('/* GENERATED */')
-    let end = oldTypeDefString.indexOf('/* /GENERATED */')
-    let newTypeDefString = oldTypeDefString.slice(0, start + 15) + '\n' + types + '\n  ' + oldTypeDefString.slice(end)
-    writeFileSync(
-      typeDefFile,
-      newTypeDefString,
-      { encoding: 'utf8' }
-    )
-
-    oldTypeDefString = readFileSync(kibanaTypeDefFile, 'utf8')
-    start = oldTypeDefString.indexOf('/* GENERATED */')
-    end = oldTypeDefString.indexOf('/* /GENERATED */')
-    newTypeDefString = oldTypeDefString.slice(0, start + 15) + '\n' + kibanaTypes + '\n  ' + oldTypeDefString.slice(end)
-    writeFileSync(
-      kibanaTypeDefFile,
-      newTypeDefString,
-      { encoding: 'utf8' }
-    )
-
     lintFiles(log, () => {
       log.text = 'Generating documentation'
       writeFileSync(

api/types.d.ts

@@ -20,7 +20,6 @@
 'use strict'
 
 const generate = require('./generateApis')
-const generateRequestTypes = require('./generateRequestTypes')
 const cloneAndCheckout = require('./clone-es')
 const genFactory = require('./generateMain')
 const generateDocs = require('./generateDocs')
@@ -29,6 +28,5 @@ module.exports = {
   generate,
   cloneAndCheckout,
   genFactory,
-  generateRequestTypes,
   generateDocs
 }

index.d.ts

@@ -20,57 +20,12 @@
 import { expectType, expectError } from 'tsd'
 import { Readable as ReadableStream } from 'stream';
 import { TransportRequestCallback, Context } from '../../lib/Transport'
-import { Client, ApiError } from '../../'
+import { Client, ApiError, estypes } from '../../'
 
 const client = new Client({
   node: 'http://localhost:9200'
 })
 
-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
 }
@@ -94,28 +49,13 @@ expectError(
     }
   })
 
-  expectType<Record<string, any>>(response.body)
-  expectType<Context>(response.meta.context)
-}
-
-// Define only the response body (promise style)
-{
-  const response = await client.search<SearchResponse<Source>>({
-    index: 'test',
-    body: {
-      query: {
-        match: { foo: 'bar' }
-      }
-    }
-  })
-
-  expectType<SearchResponse<Source>>(response.body)
+  expectType<estypes.SearchResponse<unknown>>(response.body)
   expectType<Context>(response.meta.context)
 }
 
-// Define response body and request body (promise style)
+// Define only the source (promise style)
 {
-  const response = await client.search<SearchResponse<Source>, SearchBody>({
+  const response = await client.search<Source>({
     index: 'test',
     body: {
       query: {
@@ -124,13 +64,13 @@ expectError(
     }
   })
 
-  expectType<SearchResponse<Source>>(response.body)
+  expectType<estypes.SearchResponse<Source>>(response.body)
   expectType<Context>(response.meta.context)
 }
 
 // Define response body, request body and the context (promise style)
 {
-  const response = await client.search<SearchResponse<Source>, SearchBody, Context>({
+  const response = await client.search<Source, Context>({
     index: 'test',
     body: {
       query: {
@@ -139,40 +79,7 @@ expectError(
     }
   })
 
-  expectType<SearchResponse<Source>>(response.body)
-  expectType<Context>(response.meta.context)
-}
-
-// Send request body as string (promise style)
-{
-  const response = await client.search({
-    index: 'test',
-    body: 'hello world'
-  })
-
-  expectType<Record<string, any>>(response.body)
-  expectType<Context>(response.meta.context)
-}
-
-// Send request body as buffer (promise style)
-{
-  const response = await client.search({
-    index: 'test',
-    body: Buffer.from('hello world')
-  })
-
-  expectType<Record<string, any>>(response.body)
-  expectType<Context>(response.meta.context)
-}
-
-// Send request body as readable stream (promise style)
-{
-  const response = await client.search({
-    index: 'test',
-    body: new ReadableStream()
-  })
-
-  expectType<Record<string, any>>(response.body)
+  expectType<estypes.SearchResponse<Source>>(response.body)
   expectType<Context>(response.meta.context)
 }
 
@@ -187,15 +94,15 @@ expectError(
     }
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<Record<string, any>>(response.body)
+    expectType<estypes.SearchResponse<unknown>>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
 }
 
 // Define only the response body (callback style)
 {
-  const result = client.search<SearchResponse<Source>>({
+  const result = client.search<Source>({
     index: 'test',
     body: {
       query: {
@@ -204,32 +111,15 @@ expectError(
     }
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<SearchResponse<Source>>(response.body)
-    expectType<Context>(response.meta.context)
-  })
-  expectType<TransportRequestCallback>(result)
-}
-
-// Define response body and request body (callback style)
-{
-  const result = client.search<SearchResponse<Source>, SearchBody>({
-    index: 'test',
-    body: {
-      query: {
-        match: { foo: 'bar' }
-      }
-    }
-  }, (err, response) => {
-    expectType<ApiError>(err)
-    expectType<SearchResponse<Source>>(response.body)
+    expectType<estypes.SearchResponse<Source>>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
 }
 
 // Define response body, request body and the context (callback style)
 {
-  const result = client.search<SearchResponse<Source>, SearchBody, Context>({
+  const result = client.search<Source, Context>({
     index: 'test',
     body: {
       query: {
@@ -238,46 +128,7 @@ expectError(
     }
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<SearchResponse<Source>>(response.body)
-    expectType<Context>(response.meta.context)
-  })
-  expectType<TransportRequestCallback>(result)
-}
-
-// Send request body as string (callback style)
-{
-  const result = client.search({
-    index: 'test',
-    body: 'hello world'
-  }, (err, response) => {
-    expectType<ApiError>(err)
-    expectType<Record<string, any>>(response.body)
-    expectType<Context>(response.meta.context)
-  })
-  expectType<TransportRequestCallback>(result)
-}
-
-// Send request body as buffer (callback style)
-{
-  const result = client.search({
-    index: 'test',
-    body: Buffer.from('hello world')
-  }, (err, response) => {
-    expectType<ApiError>(err)
-    expectType<Record<string, any>>(response.body)
-    expectType<Context>(response.meta.context)
-  })
-  expectType<TransportRequestCallback>(result)
-}
-
-// Send request body as readable stream (callback style)
-{
-  const result = client.search({
-    index: 'test',
-    body: new ReadableStream()
-  }, (err, response) => {
-    expectType<ApiError>(err)
-    expectType<Record<string, any>>(response.body)
+    expectType<estypes.SearchResponse<Source>>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)