teraslice-client-js 0.55.0 → 0.56.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "teraslice-client-js",
     "displayName": "Teraslice Client (JavaScript)",
-    "version": "0.55.0",
+    "version": "0.56.0",
     "description": "A Node.js client for teraslice jobs, assets, and cluster references.",
     "keywords": [
         "elasticsearch",
@@ -31,7 +31,8 @@
         "test:watch": "ts-scripts test --watch . --"
     },
     "dependencies": {
-        "@terascope/job-components": "^0.67.0",
+        "@terascope/types": "^0.14.0",
+        "@terascope/utils": "^0.55.0",
         "auto-bind": "^4.0.0",
         "got": "^11.8.3"
     },

package/src/assets.ts

@@ -1,17 +1,9 @@
-import { TSError, isEmpty, isString } from '@terascope/job-components';
+import { TSError, isEmpty, isString } from '@terascope/utils';
+import { Teraslice } from '@terascope/types';
 import path from 'path';
 import autoBind from 'auto-bind';
 import Client from './client';
-import {
-    SearchQuery,
-    PostData,
-    AssetIDResponse,
-    SearchOptions,
-    AssetUploadQuery,
-    TxtSearchParams,
-    ClientConfig,
-    Asset
-} from './interfaces';
+import { PostData, SearchOptions, ClientConfig } from './interfaces';
 
 export default class Assets extends Client {
     constructor(config: ClientConfig) {
@@ -19,7 +11,10 @@ export default class Assets extends Client {
         autoBind(this);
     }
 
-    async upload(data: PostData, query: AssetUploadQuery = {}): Promise<AssetIDResponse> {
+    async upload(
+        data: PostData,
+        query: Teraslice.AssetUploadQuery = {}
+    ): Promise<Teraslice.AssetIDResponse> {
         if (isEmpty(data)) {
             throw new TSError('Asset stream must not be empty', {
                 statusCode: 400
@@ -29,28 +24,37 @@ export default class Assets extends Client {
         const results = await this.post('/assets', data, {
             searchParams: query as Record<string, any>
         });
+
         return this.parse(results);
     }
 
-    async remove(id: string, searchOptions: SearchOptions = {}): Promise<AssetIDResponse> {
+    async remove(
+        id: string,
+        searchOptions: SearchOptions = {}
+    ): Promise<Teraslice.AssetIDResponse> {
         if (isEmpty(id)) {
             throw new TSError('Asset delete requires a ID', {
                 statusCode: 400
             });
         }
+
         const results = await this.delete(`/assets/${id}`, searchOptions);
         return this.parse(results);
     }
 
     async list(
-        query: SearchQuery = {},
+        query: Teraslice.SearchQuery = {},
         searchOptions: SearchOptions = {}
-    ): Promise<Asset[]> {
+    ): Promise<Teraslice.AssetRecord[]> {
         const options = { ...searchOptions, searchParams: query };
         return this.get('/assets', options);
     }
 
-    async getAsset(name: string, version = '', searchOptions: SearchOptions = {}): Promise<Asset[]> {
+    async getAsset(
+        name: string,
+        version = '',
+        searchOptions: SearchOptions = {}
+    ): Promise<Teraslice.AssetRecord[]> {
         if (!name || !isString(name)) {
             throw new TSError('Name is required, and must be of type string', {
                 statusCode: 400
@@ -62,14 +66,15 @@ export default class Assets extends Client {
             });
         }
 
-        const pathing = path.join('/assets', name, version);
-        return this.get(pathing, searchOptions);
+        const assetUrl = path.join('/assets', name, version);
+
+        return this.get(assetUrl, searchOptions);
     }
 
     async txt(
         name = '',
         version = '',
-        query: TxtSearchParams = {},
+        query: Teraslice.TxtSearchParams = {},
         searchOptions: SearchOptions = {}
     ): Promise<string> {
         if (name && !isString(name)) {

package/src/client.ts

@@ -1,12 +1,8 @@
 import {
-    isString,
-    TSError,
-    isPlainObject,
-    isTest,
-    trimStart,
-    tryParseJSON,
+    isString, TSError, isPlainObject,
+    isTest, trimStart, tryParseJSON,
     withoutNil,
-} from '@terascope/job-components';
+} from '@terascope/utils';
 import { STATUS_CODES } from 'http';
 import { URL } from 'url';
 import got, { Got } from 'got';
@@ -45,7 +41,7 @@ export default class Client {
         return this._makeRequest<T>('get', endpoint, options);
     }
 
-    async post<T = any>(endpoint: string, data: unknown, options?: RequestOptions): Promise<T> {
+    async post<T = any>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<T> {
         return this._makeRequest<T>('post', endpoint, options, data);
     }
 
@@ -109,7 +105,6 @@ export default class Client {
         return tryParseJSON(results);
     }
 
-    // TODO: make better types for this
     protected makeOptions(
         searchParams: Record<string, any>|undefined, options: RequestOptions | SearchOptions
     ): RequestOptions {
@@ -164,15 +159,18 @@ interface OldErrorOutput extends TSError {
 
 function makeErrorFromResponse(response: any): OldErrorOutput {
     const { statusCode } = response;
-    const stuff = getErrorFromResponse(response);
+    const parsedError = getErrorFromResponse(response);
     const {
         message = STATUS_CODES[statusCode],
         code = statusCode
-    } = stuff;
+    } = parsedError;
+
     const error: Partial<OldErrorOutput> = new Error(message);
+
     error.error = code; // for legacy support
     error.code = code;
     error.statusCode = code;
+
     return error as OldErrorOutput;
 }
 

package/src/cluster.ts

@@ -1,16 +1,10 @@
-import { startsWith } from '@terascope/job-components';
+import { startsWith } from '@terascope/utils';
+import { Teraslice } from '@terascope/types';
 import util from 'util';
 import autoBind from 'auto-bind';
 import Client from './client';
-import {
-    TxtType,
-    RootResponse,
-    ClusterState,
-    ClusterStats,
-    ControllerState
-} from './interfaces';
-
-function _deprecateSlicerName(fn: () => Promise<ControllerState>) {
+
+function _deprecateSlicerName(fn: () => Promise<Teraslice.ExecutionList>) {
     const msg = 'api endpoints with /slicers are being deprecated in favor of the semantically correct term of /controllers';
     return util.deprecate(fn, msg);
 }
@@ -22,27 +16,27 @@ export default class Cluster extends Client {
         autoBind(this);
     }
 
-    async info(): Promise<RootResponse> {
+    async info(): Promise<Teraslice.ApiRootResponse> {
         return this.get('/');
     }
 
-    async state(): Promise<ClusterState> {
+    async state(): Promise<Teraslice.ClusterState> {
         return this.get('/cluster/state');
     }
 
-    async stats(): Promise<ClusterStats> {
+    async stats(): Promise<Teraslice.ClusterStats> {
         return this.get('/cluster/stats');
     }
 
-    async slicers(): Promise<ControllerState> {
+    async slicers(): Promise<Teraslice.ExecutionList> {
         return this.get('/cluster/slicers');
     }
 
-    async controllers(): Promise<ControllerState> {
+    async controllers(): Promise<Teraslice.ExecutionList> {
         return this.get('/cluster/controllers');
     }
 
-    async txt(type: TxtType): Promise<string> {
+    async txt(type: string): Promise<string> {
         const validTypes = ['assets', 'slicers', 'ex', 'jobs', 'nodes', 'workers'];
         const isValid = validTypes.some((validType) => startsWith(type, validType));
         if (!isValid) {

package/src/ex.ts

@@ -1,35 +1,11 @@
 import {
-    isString,
-    TSError,
-    toString,
-    pDelay,
-    Assignment,
-    toHumanTime
-} from '@terascope/job-components';
+    isString, TSError, toString,
+    pDelay, toHumanTime
+} from '@terascope/utils';
+import { Teraslice } from '@terascope/types';
 import autoBind from 'auto-bind';
 import Client from './client';
-
-import {
-    ClientConfig,
-    SearchQuery,
-    SearchOptions,
-    PausedResponse,
-    StoppedResponse,
-    StopQuery,
-    Execution,
-    ResumeResponse,
-    ExecutionStatus,
-    StateErrors,
-    RequestOptions,
-    RecoverQuery,
-    ControllerState,
-    ClusterState,
-    WorkerJobProcesses,
-    ClusterProcess,
-    ChangeWorkerResponse,
-    ChangeWorkerQueryParams,
-    JobIDResponse
-} from './interfaces';
+import { ClientConfig, SearchOptions, RequestOptions } from './interfaces';
 
 export default class Ex extends Client {
     private readonly _exId: string;
@@ -45,27 +21,36 @@ export default class Ex extends Client {
 
     id(): string { return this._exId; }
 
-    async stop(query?: StopQuery, searchOptions: SearchOptions = {}): Promise<StoppedResponse> {
+    async stop(
+        query?: Teraslice.StopQuery,
+        searchOptions: SearchOptions = {}
+    ): Promise<Teraslice.ApiStoppedResponse> {
         const options = this.makeOptions(query, searchOptions);
         return this.post(`/ex/${this._exId}/_stop`, null, options);
     }
 
-    async pause(query?: SearchQuery, searchOptions: SearchOptions = {}): Promise<PausedResponse> {
+    async pause(
+        query?: Teraslice.SearchQuery,
+        searchOptions: SearchOptions = {}
+    ): Promise<Teraslice.ApiPausedResponse> {
         const options = this.makeOptions(query, searchOptions);
         return this.post(`/ex/${this._exId}/_pause`, null, options);
     }
 
-    async resume(query?: SearchQuery, searchOptions: SearchOptions = {}): Promise<ResumeResponse> {
+    async resume(
+        query?: Teraslice.SearchQuery,
+        searchOptions: SearchOptions = {}
+    ): Promise<Teraslice.ApiResumeResponse> {
         const options = this.makeOptions(query, searchOptions);
         return this.post(`/ex/${this._exId}/_resume`, null, options);
     }
 
     async recover(
-        query: RecoverQuery = {},
+        query: Teraslice.RecoverQuery = {},
         searchOptions: SearchOptions = {}
     ): Promise<Ex> {
         const options = this.makeOptions(query, searchOptions);
-        const result: JobIDResponse = await this.post(`/ex/${this._exId}/_recover`, null, options);
+        const result: Teraslice.ApiJobCreateResponse = await this.post(`/ex/${this._exId}/_recover`, null, options);
 
         // support older version of teraslice
         if (!result.ex_id) {
@@ -76,39 +61,39 @@ export default class Ex extends Client {
         return new Ex(this._config, result.ex_id);
     }
 
-    async status(requestOptions?: RequestOptions): Promise<ExecutionStatus> {
+    async status(requestOptions?: RequestOptions): Promise<Teraslice.ExecutionStatus> {
         const { _status: status } = await this.config(requestOptions);
         return status;
     }
 
-    async slicer(requestOptions: RequestOptions = {}): Promise<ControllerState> {
+    async slicer(requestOptions: RequestOptions = {}): Promise<Teraslice.ExecutionList> {
         return this.get(`/ex/${this._exId}/slicer`, requestOptions);
     }
 
-    async controller(requestOptions: RequestOptions = {}): Promise<ControllerState> {
+    async controller(requestOptions: RequestOptions = {}): Promise<Teraslice.ExecutionList> {
         return this.get(`/ex/${this._exId}/controller`, requestOptions);
     }
 
-    async config(requestOptions: RequestOptions = {}): Promise<Execution> {
+    async config(requestOptions: RequestOptions = {}): Promise<Teraslice.ExecutionRecord> {
         return this.get(`/ex/${this._exId}`, requestOptions);
     }
 
-    async workers(requestOptions: RequestOptions = {}): Promise<WorkerJobProcesses[]> {
-        const state: ClusterState = await this.get('/cluster/state', requestOptions);
-        return filterProcesses<WorkerJobProcesses>(state, this._exId, 'worker');
+    async workers(requestOptions: RequestOptions = {}): Promise<Teraslice.WorkerNode[]> {
+        const state: Teraslice.ClusterState = await this.get('/cluster/state', requestOptions);
+        return filterProcesses<Teraslice.WorkerNode>(state, this._exId, 'worker');
     }
 
-    async errors(options?: SearchQuery): Promise<StateErrors> {
+    async errors(options?: Teraslice.SearchQuery): Promise<Teraslice.ErrorRecord[]> {
         return this.get(`/ex/${this._exId}/errors`, {
             searchParams: options,
         } as SearchOptions);
     }
 
     async changeWorkers(
-        action: ChangeWorkerQueryParams,
+        action: Teraslice.ChangeWorkerQueryParams,
         workerNum: number,
         requestOptions: RequestOptions = {}
-    ): Promise<ChangeWorkerResponse | string> {
+    ): Promise<Teraslice.ChangeWorkerResponse | string> {
         if (action == null || workerNum == null) {
             throw new TSError('Change workers requires action and count', {
                 statusCode: 400
@@ -138,17 +123,17 @@ export default class Ex extends Client {
     }
 
     async waitForStatus(
-        target: ExecutionStatus,
+        target: Teraslice.ExecutionStatus,
         intervalMs = 1000,
         timeoutMs = 0,
         requestOptions: RequestOptions = {}
-    ): Promise<ExecutionStatus> {
+    ): Promise<Teraslice.ExecutionStatus> {
         const terminal = {
-            [ExecutionStatus.terminated]: true,
-            [ExecutionStatus.failed]: true,
-            [ExecutionStatus.rejected]: true,
-            [ExecutionStatus.completed]: true,
-            [ExecutionStatus.stopped]: true,
+            [Teraslice.ExecutionStatusEnum.terminated]: true,
+            [Teraslice.ExecutionStatusEnum.failed]: true,
+            [Teraslice.ExecutionStatusEnum.rejected]: true,
+            [Teraslice.ExecutionStatusEnum.completed]: true,
+            [Teraslice.ExecutionStatusEnum.stopped]: true,
         };
 
         const startTime = Date.now();
@@ -157,7 +142,7 @@ export default class Ex extends Client {
             timeout: intervalMs < 1000 ? 1000 : intervalMs,
         }, requestOptions);
 
-        const checkStatus = async (): Promise<ExecutionStatus> => {
+        const checkStatus = async (): Promise<Teraslice.ExecutionStatus> => {
             let result;
             try {
                 result = await this.status(options);
@@ -212,11 +197,16 @@ function validateExId(exId?: string) {
     }
 }
 
-function filterProcesses<T>(state: ClusterState, exId: string, type: Assignment) {
+function filterProcesses<T>(
+    state: Teraslice.ClusterState,
+    exId: string,
+    type: Teraslice.Assignment
+) {
     const results: T[] = [];
 
     for (const node of Object.values(state)) {
-        node.active.forEach((child: ClusterProcess) => {
+        // TODO: fixme
+        node.active.forEach((child: any) => {
             const { assignment, ex_id: procExId } = child;
             if ((assignment && assignment === type) && (procExId && procExId === exId)) {
                 const jobProcess = Object.assign({}, child, { node_id: node.node_id });

package/src/executions.ts

@@ -1,24 +1,14 @@
 import {
-    isString,
-    isPlainObject,
-    JobConfig,
-    TSError,
-    unset
-} from '@terascope/job-components';
+    isString, isPlainObject, TSError, unset
+} from '@terascope/utils';
+import { Teraslice } from '@terascope/types';
 import autoBind from 'auto-bind';
 import Client from './client';
 import Ex from './ex';
 
-import {
-    ClientConfig,
-    SearchQuery,
-    SearchOptions,
-    StateErrors,
-    Execution,
-    JobIDResponse,
-} from './interfaces';
+import { ClientConfig, SearchOptions } from './interfaces';
 
-type ListOptions = undefined | string | SearchQuery;
+type ListOptions = undefined | string | Teraslice.SearchQuery;
 
 export default class Executions extends Client {
     constructor(config: ClientConfig) {
@@ -29,13 +19,13 @@ export default class Executions extends Client {
     /**
      * Similar to jobs.submit but returns an instance of Ex not a Job
     */
-    async submit(jobSpec: JobConfig, shouldNotStart?: boolean): Promise<Ex> {
+    async submit(jobSpec: Teraslice.JobConfig, shouldNotStart?: boolean): Promise<Ex> {
         if (!jobSpec) {
             throw new TSError('Submit requires a jobSpec', {
                 statusCode: 400
             });
         }
-        const job: JobIDResponse = await this.post('/jobs', jobSpec, {
+        const job: Teraslice.ApiJobCreateResponse = await this.post('/jobs', jobSpec, {
             searchParams: { start: !shouldNotStart }
         });
         // support older version of teraslice
@@ -43,16 +33,20 @@ export default class Executions extends Client {
             const { ex_id: exId } = await this.get(`/jobs/${job.job_id}/ex`);
             return this.wrap(exId);
         }
+
         return this.wrap(job.ex_id);
     }
 
-    async list(options?: ListOptions): Promise<Execution[]> {
+    async list(options?: ListOptions): Promise<Teraslice.ExecutionRecord[]> {
         const query = _parseListOptions(options);
         return this.get('/ex', { searchParams: query } as SearchOptions);
     }
 
-    async errors(exId?: string | SearchQuery, opts?: SearchQuery): Promise<StateErrors> {
-        const options: SearchQuery = {};
+    async errors(
+        exId?: string | Teraslice.SearchQuery,
+        opts?: Teraslice.SearchQuery
+    ): Promise<Teraslice.ErrorRecord[]> {
+        const options: Teraslice.SearchQuery = {};
         if (isString(exId)) {
             if (isPlainObject(opts)) {
                 options.searchParams = opts;
@@ -77,7 +71,7 @@ export default class Executions extends Client {
     }
 }
 
-function _parseListOptions(options: ListOptions): SearchQuery {
+function _parseListOptions(options: ListOptions): Teraslice.SearchQuery {
     // support legacy
     if (!options) return {};
     if (isString(options)) {