remove dual callback/promise functioning

and hence remove usage of promisify

TODO handle TODOs

TODO check tests

TODO notice the stuff that we've had to force unwrap here, and undo
later if possible

src/common/lib/client/baseclient.ts

@@ -129,27 +129,23 @@ class BaseClient {
     return Defaults.getHttpScheme(this.options) + host + ':' + Defaults.getPort(this.options, false);
   }
 
-  stats(
-    params: RequestParams,
-    callback: StandardCallback<PaginatedResult<Stats>>
-  ): Promise<PaginatedResult<Stats>> | void {
-    return this.rest.stats(params, callback);
+  async stats(params: RequestParams): Promise<PaginatedResult<Stats>> {
+    return this.rest.stats(params);
   }
 
-  time(params?: RequestParams | StandardCallback<number>, callback?: StandardCallback<number>): Promise<number> | void {
-    return this.rest.time(params, callback);
+  async time(params?: RequestParams): Promise<number> {
+    return this.rest.time(params);
   }
 
-  request(
+  async request(
     method: string,
     path: string,
     version: number,
     params: RequestParams,
     body: unknown,
-    customHeaders: Record<string, string>,
-    callback: StandardCallback<HttpPaginatedResponse<unknown>>
-  ): Promise<HttpPaginatedResponse<unknown>> | void {
-    return this.rest.request(method, path, version, params, body, customHeaders, callback);
+    customHeaders: Record<string, string>
+  ): Promise<HttpPaginatedResponse<unknown>> {
+    return this.rest.request(method, path, version, params, body, customHeaders);
   }
 
   batchPublish<T extends BatchPublishSpec | BatchPublishSpec[]>(

src/common/lib/client/connection.ts

@@ -1,4 +1,3 @@
-import * as Utils from '../util/utils';
 import EventEmitter from '../util/eventemitter';
 import ConnectionManager from '../transport/connectionmanager';
 import Logger from '../util/logger';
@@ -53,12 +52,11 @@ class Connection extends EventEmitter {
     this.connectionManager.requestState({ state: 'connecting' });
   }
 
-  ping(callback: Function): Promise<number> | void {
+  async ping(): Promise<number> {
     Logger.logAction(Logger.LOG_MINOR, 'Connection.ping()', '');
-    if (!callback) {
-      return Utils.promisify(this, 'ping', arguments);
-    }
-    this.connectionManager.ping(null, callback);
+    return new Promise((resolve, reject) => {
+      this.connectionManager.ping(null, (err: unknown, result: number) => (err ? reject(err) : resolve(result)));
+    });
   }
 
   close(): void {

src/common/lib/client/paginatedresource.ts

@@ -1,7 +1,7 @@
 import * as Utils from '../util/utils';
 import Logger from '../util/logger';
 import Resource from './resource';
-import ErrorInfo, { IPartialErrorInfo } from '../types/errorinfo';
+import { IPartialErrorInfo } from '../types/errorinfo';
 import { PaginatedResultCallback } from '../../types/utils';
 import BaseClient from './baseclient';
 import { RequestCallbackHeaders } from 'common/types/http';
@@ -187,9 +187,9 @@ interface PaginatedResultLoadFunction<T> {
 export class PaginatedResult<T> {
   resource: PaginatedResource;
   items: T[];
-  first?: PaginatedResultLoadFunction<T>;
-  next?: PaginatedResultLoadFunction<T>;
-  current?: PaginatedResultLoadFunction<T>;
+  first?: () => Promise<PaginatedResult<T>>;
+  next?: () => Promise<PaginatedResult<T>>;
+  current?: () => Promise<PaginatedResult<T>>;
   hasNext?: () => boolean;
   isLast?: () => boolean;
 
@@ -200,29 +200,28 @@ export class PaginatedResult<T> {
     const self = this;
     if (relParams) {
       if ('first' in relParams) {
-        this.first = function (callback?: (result?: ErrorInfo | null) => void) {
-          if (!callback) {
-            return Utils.promisify(self, 'first', []);
-          }
-          self.get(relParams.first, callback);
+        this.first = async function () {
+          return new Promise((resolve, reject) => {
+            self.get(relParams.first, (err, result) => (err ? reject(err) : resolve(result)));
+          });
         };
       }
       if ('current' in relParams) {
-        this.current = function (callback?: (results?: ErrorInfo | null) => void) {
-          if (!callback) {
-            return Utils.promisify(self, 'current', []);
-          }
-          self.get(relParams.current, callback);
+        this.current = async function () {
+          return new Promise((resolve, reject) => {
+            self.get(relParams.current, (err, result) => (err ? reject(err) : resolve(result)));
+          });
         };
       }
-      this.next = function (callback?: (results?: ErrorInfo | null) => void) {
-        if (!callback) {
-          return Utils.promisify(self, 'next', []);
-        }
+      this.next = async function () {
         if ('next' in relParams) {
-          self.get(relParams.next, callback);
+          return new Promise((resolve, reject) => {
+            self.get(relParams.next, (err, result) => (err ? reject(err) : resolve(result)));
+          });
         } else {
-          callback(null);
+          // TODO what is this? this looks a bit odd
+          //callback(null);
+          throw new Error('there is no next page');
         }
       };