Change signature of start and call methods

package.json

@@ -1,6 +1,6 @@
 {
     "name": "apify-client",
-    "version": "1.0.0-beta.7",
+    "version": "1.0.0-beta.8",
     "description": "Apify API client for JavaScript",
     "main": "src/index.js",
     "keywords": [

src/resource_clients/actor.js

@@ -26,15 +26,25 @@ class ActorClient extends ResourceClient {
         });
     }
 
-    async start(options = {}) {
+    /**
+     * @param {*} [input]
+     * @param {object} [options]
+     * @param {string} [options.build]
+     * @param {string} [options.contentType]
+     * @param {number} [options.memory]
+     * @param {number} [options.timeout]
+     * @param {array} [options.webhooks]
+     * @return {Promise<Run>}
+     */
+    async start(input, options = {}) {
+        // input can be anything, pointless to validate
         ow(options, ow.object.exactShape({
+            build: ow.optional.string,
             contentType: ow.optional.string,
-            waitForFinish: ow.optional.number,
-            timeout: ow.optional.number,
             memory: ow.optional.number,
-            build: ow.optional.string,
+            timeout: ow.optional.number,
+            waitForFinish: ow.optional.number,
             webhooks: ow.optional.array.ofType(ow.object),
-            input: ow.any,
         }));
 
         const { waitForFinish, timeout, memory, build } = options;
@@ -50,7 +60,7 @@ class ActorClient extends ResourceClient {
         const request = {
             url: this._url('runs'),
             method: 'POST',
-            data: options.input,
+            data: input,
             params: this._params(params),
         };
         if (options.contentType) {
@@ -63,24 +73,33 @@ class ActorClient extends ResourceClient {
         return parseDateFields(pluckData(response.data));
     }
 
-    async call(options = {}) {
+    /**
+     * @param {*} [input]
+     * @param {object} [options]
+     * @param {string} [options.build]
+     * @param {string} [options.contentType]
+     * @param {number} [options.memory]
+     * @param {number} [options.timeout]
+     * @param {number} [options.waitSecs]
+     * @param {array} [options.webhooks]
+     * @return {Promise<Run>}
+     */
+    async call(input, options = {}) {
+        // input can be anything, pointless to validate
         ow(options, ow.object.exactShape({
+            build: ow.optional.string,
             contentType: ow.optional.string,
             memory: ow.optional.number,
             timeout: ow.optional.number.not.negative,
-            build: ow.optional.string,
             waitSecs: ow.optional.number.not.negative,
             webhooks: ow.optional.array.ofType(ow.object),
-            input: ow.any,
         }));
 
         const { waitSecs, ...startOptions } = options;
 
-        const { id, actId } = await this.start(startOptions);
-
-        const response = this.apifyClient.run(id, actId).waitForFinish({ waitSecs });
+        const { id, actId } = await this.start(input, startOptions);
 
-        return response;
+        return this.apifyClient.run(id, actId).waitForFinish({ waitSecs });
     }
 
     async build(options = {}) {

src/resource_clients/task.js

@@ -20,14 +20,23 @@ class TaskClient extends ResourceClient {
         });
     }
 
-    async start(options = {}) {
+    /**
+     * @param {object} [input]
+     * @param {object} [options]
+     * @param {string} [options.build]
+     * @param {number} [options.memory]
+     * @param {number} [options.timeout]
+     * @param {array} [options.webhooks]
+     * @return {Promise<Run>}
+     */
+    async start(input, options = {}) {
+        ow(input, ow.optional.object);
         ow(options, ow.object.exactShape({
-            waitForFinish: ow.optional.number,
-            timeout: ow.optional.number,
-            memory: ow.optional.number,
             build: ow.optional.string,
+            memory: ow.optional.number,
+            timeout: ow.optional.number,
+            waitForFinish: ow.optional.number,
             webhooks: ow.optional.array.ofType(ow.object),
-            input: ow.optional.object,
         }));
 
         const { waitForFinish, timeout, memory, build } = options;
@@ -43,31 +52,39 @@ class TaskClient extends ResourceClient {
         const request = {
             url: this._url('runs'),
             method: 'POST',
-            data: options.input,
+            data: input,
             params: this._params(params),
         };
 
         const response = await this.httpClient.call(request);
         return parseDateFields(pluckData(response.data));
     }
 
-    async call(options = {}) {
+    /**
+     * @param {object} [input]
+     * @param {object} [options]
+     * @param {string} [options.build]
+     * @param {number} [options.memory]
+     * @param {number} [options.timeout]
+     * @param {number} [options.waitSecs]
+     * @param {array} [options.webhooks]
+     * @return {Promise<Run>}
+     */
+    async call(input, options = {}) {
+        ow(input, ow.optional.object);
         ow(options, ow.object.exactShape({
+            build: ow.optional.string,
             memory: ow.optional.number,
             timeout: ow.optional.number.not.negative,
-            build: ow.optional.string,
-            waitSecs: ow.optional.number,
+            waitSecs: ow.optional.number.not.negative,
             webhooks: ow.optional.array.ofType(ow.object),
-            input: ow.optional.object,
         }));
 
         const { waitSecs, ...startOptions } = options;
 
-        const { id, actId } = await this.start(startOptions);
-
-        const response = this.apifyClient.run(id, actId).waitForFinish({ waitSecs });
+        const { id, actId } = await this.start(input, startOptions);
 
-        return response;
+        return this.apifyClient.run(id, actId).waitForFinish({ waitSecs });
     }
 
     async getInput() {

test/actors.test.js

@@ -124,11 +124,11 @@ describe('Actor methods', () => {
                 build: '1.2.0',
             };
 
-            const res = await client.actor(actorId).start({ contentType, input, ...query });
+            const res = await client.actor(actorId).start(input, { contentType, ...query });
             expect(res.id).toEqual('run-actor');
             validateRequest(query, { actorId }, { some: 'body' }, { 'content-type': contentType });
 
-            const browserRes = await page.evaluate((id, opts) => client.actor(id).start(opts), actorId, { contentType, input, ...query });
+            const browserRes = await page.evaluate((id, i, opts) => client.actor(id).start(i, opts), actorId, input, { contentType, ...query });
             expect(browserRes).toEqual(res);
             validateRequest(query, { actorId }, { some: 'body' }, { 'content-type': contentType });
         });
@@ -146,11 +146,11 @@ describe('Actor methods', () => {
                 },
             ];
 
-            const res = await client.actor(actorId).start({ webhooks });
+            const res = await client.actor(actorId).start(undefined, { webhooks });
             expect(res.id).toEqual('run-actor');
             validateRequest({ webhooks: stringifyWebhooksToBase64(webhooks) }, { actorId });
 
-            const browserRes = await page.evaluate((id, opts) => client.actor(id).start(opts), actorId, { webhooks });
+            const browserRes = await page.evaluate((id, opts) => client.actor(id).start(undefined, opts), actorId, { webhooks });
             expect(browserRes).toEqual(res);
             validateRequest({ webhooks: stringifyWebhooksToBase64(webhooks) }, { actorId });
         });
@@ -168,12 +168,11 @@ describe('Actor methods', () => {
             const waitSecs = 1;
 
             mockServer.setResponse({ body });
-            const res = await client.actor(actorId).call({
+            const res = await client.actor(actorId).call(input, {
                 contentType,
                 memory,
                 timeout,
                 build,
-                input,
                 waitSecs,
             });
 
@@ -186,12 +185,11 @@ describe('Actor methods', () => {
             }, { actorId }, { some: 'body' }, { 'content-type': contentType });
 
             const callBrowserRes = await page.evaluate(
-                (id, opts) => client.actor(id).call(opts), actorId, {
+                (id, i, opts) => client.actor(id).call(i, opts), actorId, input, {
                     contentType,
                     memory,
                     timeout,
                     build,
-                    input,
                     waitSecs,
                 },
             );

test/tasks.test.js

@@ -135,17 +135,14 @@ describe('Task methods', () => {
 
         test('start() works', async () => {
             const taskId = 'some-id';
-            const query = {
-                waitForFinish: 100,
-            };
 
-            const res = await client.task(taskId).start(query);
+            const res = await client.task(taskId).start();
             expect(res.id).toEqual('run-task');
-            validateRequest(query, { taskId });
+            validateRequest({}, { taskId });
 
-            const browserRes = await page.evaluate((id, q) => client.task(id).start(q), taskId, query);
+            const browserRes = await page.evaluate((id) => client.task(id).start(), taskId);
             expect(browserRes).toEqual(res);
-            validateRequest(query, { taskId });
+            validateRequest({}, { taskId });
         });
 
         test('start() works with input and options overrides', async () => {
@@ -157,11 +154,11 @@ describe('Task methods', () => {
                 memory: 512,
             };
 
-            const res = await client.task(taskId).start({ input, ...query });
+            const res = await client.task(taskId).start(input, query);
             expect(res.id).toEqual('run-task');
             validateRequest(query, { taskId }, input);
 
-            const browserRes = await page.evaluate((id, opts) => client.task(id).start(opts), taskId, { input, ...query });
+            const browserRes = await page.evaluate((id, i, opts) => client.task(id).start(i, opts), taskId, input, query);
             expect(browserRes).toEqual(res);
             validateRequest(query, { taskId }, input);
         });
@@ -180,11 +177,11 @@ describe('Task methods', () => {
             ];
 
             const query = { webhooks: stringifyWebhooksToBase64(webhooks) };
-            const res = await client.task(taskId).start({ webhooks });
+            const res = await client.task(taskId).start(undefined, { webhooks });
             expect(res.id).toEqual('run-task');
             validateRequest(query, { taskId });
 
-            const browserRes = await page.evaluate((id, opts) => client.task(id).start(opts), taskId, { webhooks });
+            const browserRes = await page.evaluate((id, opts) => client.task(id).start(undefined, opts), taskId, { webhooks });
             expect(browserRes).toEqual(res);
             validateRequest(query, { taskId });
         });
@@ -208,11 +205,10 @@ describe('Task methods', () => {
             };
 
             mockServer.setResponse({ body });
-            const res = await client.task(taskId).call({
+            const res = await client.task(taskId).call(input, {
                 memory,
                 timeout,
                 build,
-                input,
                 waitSecs,
             });
             expect(res).toEqual(data);
@@ -222,11 +218,10 @@ describe('Task methods', () => {
             validateRequest(query, { taskId }, { some: 'body' });
 
             const callBrowserRes = await page.evaluate(
-                (id, opts) => client.task(id).call(opts), taskId, {
+                (id, i, opts) => client.task(id).call(i, opts), taskId, input, {
                     memory,
                     timeout,
                     build,
-                    input,
                     waitSecs,
                 },
             );