teraslice-client-js 2.12.2 → 2.14.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "teraslice-client-js",
   "displayName": "Teraslice Client (JavaScript)",
-  "version": "2.12.2",
+  "version": "2.14.0",
   "description": "A Node.js client for teraslice jobs, assets, and cluster references.",
   "keywords": [
     "elasticsearch",
@@ -26,13 +26,13 @@
   },
   "dependencies": {
     "auto-bind": "~5.0.1",
-    "got": "~15.0.6",
-    "@terascope/core-utils": "~2.12.1",
-    "@terascope/types": "~2.12.0"
+    "got": "~15.1.0",
+    "@terascope/core-utils": "~2.14.0",
+    "@terascope/types": "~2.13.0"
   },
   "devDependencies": {
     "jest-extended": "~7.0.0",
-    "nock": "~14.0.15"
+    "nock": "~14.0.16"
   },
   "engines": {
     "node": ">=22.0.0",

package/src/job.ts

@@ -87,13 +87,13 @@ export default class Job extends Client {
         return this.post(`/jobs/${this._jobId}/_recover`, null, options);
     }
 
-    async update(jobSpec: Teraslice.JobConfig): Promise<Teraslice.JobConfig> {
+    async update(jobSpec: Teraslice.JobConfig): Promise<Teraslice.ApiJobUpdateResponse> {
         return this.put(`/jobs/${this._jobId}`, jobSpec);
     }
 
     async updatePartial(
         jobSpec: Partial<Teraslice.JobConfig>
-    ): Promise<Teraslice.JobConfig> {
+    ): Promise<Teraslice.ApiJobUpdateResponse> {
         const current = await this.config();
         const body: Teraslice.JobConfig = Object.assign({}, current, jobSpec);
         return this.update(body);

package/src/jobs.ts

@@ -25,6 +25,30 @@ export default class Jobs extends Client {
         return this.wrap(job.job_id);
     }
 
+    // TODO: Teraslice v4 this exists to avoid a breaking change to submit() which returns just
+    // the Job. This is only used by teraslice-cli. In Teraslice v4, submit() should
+    // be updated to return warnings and this method removed.
+    // See https://github.com/terascope/teraslice/issues/4501
+    async submitWithWarnings(
+        jobSpec: Teraslice.JobConfigParams,
+        shouldNotStart?: boolean
+    ): Promise<{ job: Job; warnings: Teraslice.JobWarning[] }> {
+        if (!jobSpec) {
+            throw new TSError('Submit requires a jobSpec', {
+                statusCode: 400
+            });
+        }
+
+        const response: Teraslice.ApiJobCreateResponse = await this.post('/jobs', jobSpec, {
+            searchParams: { start: !shouldNotStart }
+        });
+
+        return {
+            job: this.wrap(response.job_id),
+            warnings: response.warnings ?? []
+        };
+    }
+
     async list(
         query?: Teraslice.JobSearchParams,
         searchOptions: RequestOptions = {}

package/test/job-spec.ts

@@ -223,6 +223,41 @@ describe('Teraslice Job', () => {
         });
     });
 
+    describe('->start', () => {
+        describe('when the server returns deprecation warnings', () => {
+            const deprecationWarning: Teraslice.JobWarning = {
+                type: 'JobValidation',
+                reason: {
+                    type: 'assetOperation',
+                    kind: 'deprecation',
+                    reason: {
+                        _op: 'some-op',
+                        field: 'old_field',
+                        description: 'old_field is deprecated, use new_field instead',
+                    },
+                },
+            };
+
+            const response: Teraslice.ApiJobCreateResponse = {
+                job_id: 'some-job-id',
+                warnings: [deprecationWarning],
+            };
+
+            beforeEach(() => {
+                scope.post('/jobs/some-job-id/_start')
+                    .reply(200, response);
+            });
+
+            it('should return the response with warnings', async () => {
+                const job = new Job({ baseUrl }, 'some-job-id');
+                const result = await job.start();
+                expect(result.job_id).toEqual('some-job-id');
+                expect(result.warnings).toBeArrayOfSize(1);
+                expect(result.warnings![0]).toMatchObject(deprecationWarning);
+            });
+        });
+    });
+
     describe('->recover', () => {
         describe('when called with nothing', () => {
             beforeEach(() => {
@@ -275,6 +310,41 @@ describe('Teraslice Job', () => {
         });
     });
 
+    describe('->recover with warnings', () => {
+        describe('when the server returns deprecation warnings', () => {
+            const deprecationWarning: Teraslice.JobWarning = {
+                type: 'JobValidation',
+                reason: {
+                    type: 'assetAPIProperty',
+                    kind: 'deprecation',
+                    reason: {
+                        api_name: 'some-api',
+                        field: 'old_api_field',
+                        description: 'old_api_field is deprecated, use new_api_field instead',
+                    },
+                },
+            };
+
+            const response: Teraslice.ApiJobCreateResponse = {
+                job_id: 'some-other-job-id',
+                warnings: [deprecationWarning],
+            };
+
+            beforeEach(() => {
+                scope.post('/jobs/some-other-job-id/_recover')
+                    .reply(200, response);
+            });
+
+            it('should return the response with warnings', async () => {
+                const job = new Job({ baseUrl }, 'some-other-job-id');
+                const result = await job.recover();
+                expect(result.job_id).toEqual('some-other-job-id');
+                expect(result.warnings).toBeArrayOfSize(1);
+                expect(result.warnings![0]).toMatchObject(deprecationWarning);
+            });
+        });
+    });
+
     describe('->execution', () => {
         const exJobId = executionResults[0].job_id;
         describe('when called with nothing', () => {

package/test/jobs-spec.ts

@@ -164,6 +164,81 @@ describe('Teraslice Jobs', () => {
         });
     });
 
+    describe('->submitWithWarnings', () => {
+        describe('when submitting without a jobSpec', () => {
+            it('should fail', async () => {
+                expect.hasAssertions();
+                try {
+                    // @ts-expect-error
+                    await jobs.submitWithWarnings();
+                } catch (err) {
+                    expect(err.message).toEqual('Submit requires a jobSpec');
+                }
+            });
+        });
+
+        describe('when the server returns warnings', () => {
+            const jobSpec = { operations: [{ _op: 'operation' }] };
+            const response = {
+                job_id: 'some-job-id',
+                warnings: [{
+                    type: 'JobValidation',
+                    reason: {
+                        type: 'assetOperation',
+                        kind: 'deprecation',
+                        reason: {
+                            _op: 'operation',
+                            field: 'old_field',
+                            description: 'old_field is deprecated',
+                        },
+                    },
+                }]
+            };
+
+            beforeEach(() => {
+                scope.post('/jobs', jobSpec)
+                    .query({ start: false })
+                    .reply(202, response);
+            });
+
+            it('should return the job and warnings', async () => {
+                const result = await jobs.submitWithWarnings(jobSpec, true);
+                expect(result.job).toBeInstanceOf(Job);
+                expect(result.job.id()).toEqual(response.job_id);
+                expect(result.warnings).toBeArrayOfSize(1);
+                expect(result.warnings[0]).toMatchObject({
+                    type: 'JobValidation',
+                    reason: {
+                        type: 'assetOperation',
+                        kind: 'deprecation',
+                        reason: {
+                            _op: 'operation',
+                            field: 'old_field',
+                            description: 'old_field is deprecated',
+                        },
+                    },
+                });
+            });
+        });
+
+        describe('when the response includes no warnings field', () => {
+            const jobSpec = { operations: [{ _op: 'operation' }] };
+            const response = { job_id: 'some-job-id' };
+
+            beforeEach(() => {
+                scope.post('/jobs', jobSpec)
+                    .query({ start: false })
+                    .reply(202, response);
+            });
+
+            it('should return the job with an empty warnings array', async () => {
+                const result = await jobs.submitWithWarnings(jobSpec, true);
+                expect(result.job).toBeInstanceOf(Job);
+                expect(result.warnings).toBeArrayOfSize(0);
+            });
+        });
+    });
+
     describe('->list', () => {
         describe('when called with nothing', () => {
             beforeEach(() => {