fix: Removed xhr library in favour of ky, and switched request for got for a smaller package size and retry functionality

Author: jdalrymple

README.md

@@ -147,43 +147,26 @@ Instantiate the library using a basic token created in your [Gitlab Profile](htt
 
 ```javascript
 // ES6 (>=node 8.9.0)
-import { Gitlab } from 'gitlab';
+import { Gitlab } from 'gitlab';   // All Resources
+import { Projects } from 'gitlab'; // Just the Project Resource
+//...etc
 
 // ES5, assuming native or polyfilled Promise is available
 const { Gitlab } = require('gitlab');
-
-// Instantiating
-const api = new Gitlab({
-  host: 'http://example.com', // Defaults to https://gitlab.com
-  token: 'abcdefghij123456', // Can be created in your profile.
-});
-
-// Or, use a OAuth token instead!
-
-const api = new Gitlab({
-  host: 'http://example.com', // Defaults to https://gitlab.com
-  oauthToken: 'abcdefghij123456',
-});
-
-// You can also use a CI job token:
-
-const api = new Gitlab({
-  url: 'http://example.com', // Defaults to https://gitlab.com
-  jobToken: process.env.CI_JOB_TOKEN,
-});
 ```
 
-#### Specific Imports
-
-Sometimes you don't want to import and instantiate the whole Gitlab API, perhaps you only want access to the Projects API. To do this, one only needs to import and instantiate this specific API:
-
+Instatiating options:
 ```javascript
-import { Projects } from 'gitlab';
-
-const service = new Projects({
-  host: 'http://example.com', // Defaults to https://gitlab.com
-  token: 'abcdefghij123456', // Can be created in your profile.
+const api = new Gitlab({
+  host: 'http://gl.com',    //Optional, Default: https://gitlab.com
+  token: 'personaltoken',   //Personal Token. Required (one of the three tokens are required)
+  oauthToken: 'oauthtoken', //OAuth Token. Required (one of the three tokens are required)
+  jobToken: 'myJobToken',   //CI job token. Required (one of the three tokens are required)
+  rejectUnauthorized: false //Http Certificate setting. Optional, Default: false
+  sudo: false               //Sudo query parameter. Optional, Default: false
+  version = 'v4',           //API Version ID. Optional, Default: v4
   camelize = false,         //Response Key Camelize. Camelizes all response body keys. Optional, Default: false
+  requester = KyRequester,  //Request Library Wrapper. Optional, Default: Currently wraps Ky.
 });
 ```
 

src/index.ts

@@ -1,3 +1,7 @@
+import { shim } from 'universal-url';
+
+// Add URL shim
+shim();
 
 import { bundler } from './infrastructure';
 import * as APIServices from './services';

src/infrastructure/BaseService.ts

@@ -1,53 +1,36 @@
-import URLJoin from 'url-join';
-import Request from 'request-promise';
-import XMLHttpRequester, { XhrStaticPromisified } from './XMLHttpRequester';
+import { KyRequester } from './KyRequester';
 
-interface BaseModelOptions {
+export class BaseService {
   public readonly url: string;
-  token?: string;
-  oauthToken?: string;
+  public readonly requester: Requester;
+  public readonly headers: { [header: string]: string };
   public readonly camelize: boolean;
-  version?: string;
-  sudo?: string | number;
-  rejectUnauthorized?: boolean;
-}
-
-export type BaseModelContructorOptions =
-  | BaseModelOptions & Required<Pick<BaseModelOptions, 'token'>>
-  | BaseModelOptions & Required<Pick<BaseModelOptions, 'oauthToken'>>;
-class BaseModel {
-  public url: string;
-  public readonly headers: { [header: string]: string | number};
   public readonly rejectUnauthorized: boolean;
-  public readonly requester: XhrStaticPromisified;
-  public readonly useXMLHttpRequest: boolean;
 
   constructor({
     token,
+    jobToken,
     oauthToken,
     sudo,
     host = 'https://gitlab.com',
     url = '',
     version = 'v4',
     camelize = false,
     rejectUnauthorized = true,
-  }: BaseModelContructorOptions) {
+    requester = KyRequester,
   }: BaseServiceOptions) {
     this.url = [host, 'api', version, url].join('/');
     this.headers = {};
-    this.requester = useXMLHttpRequest
-      ? XMLHttpRequester : (Request as temporaryAny as XhrStaticPromisified);
-    this.useXMLHttpRequest = useXMLHttpRequest;
     this.rejectUnauthorized = rejectUnauthorized;
     this.camelize = camelize;
+    this.requester = requester;
 
     // Handle auth tokens
     if (oauthToken) this.headers.authorization = `Bearer ${oauthToken}`;
+    else if (jobToken) this.headers['job-token'] = jobToken;
     else if (token) this.headers['private-token'] = token;
 
     // Set sudo
     if (sudo) this.headers['Sudo'] = `${sudo}`;
   }
 }
-
-export default BaseModel;

src/infrastructure/KyRequester.ts

@@ -0,0 +1,61 @@
+import Ky from 'ky-universal';
+import { decamelizeKeys } from 'humps';
+import { stringify } from 'query-string';
+import { skipAllCaps } from './Utils';
+
+const methods = ['get', 'post', 'put', 'delete'];
+const KyRequester = {} as Requester;
+
+function responseHeadersAsObject(response) {
+    const headers = {}
+    const keyVals = [...response.headers.entries()]
+   
+    keyVals.forEach(([key, val]) => {
+        headers[key] = val
+    })
+
+    return headers
+}
+
+function defaultRequest(
+  service: any,
+  endpoint: string,
+  { body, query, sudo }: DefaultRequestOptions,
+) {
+  const headers = new Headers(service.headers);
+
+  if (sudo) headers.append('sudo', `${sudo}`);
+
+  return [
+    endpoint,
+    {
+      timeout: 30000,
+      headers,
+      searchParams: stringify(decamelizeKeys(query || {}), { arrayFormat: 'bracket' }),
+      prefixUrl: service.url,
+      json: typeof body === 'object' ? decamelizeKeys(body, skipAllCaps) : body,
+      rejectUnauthorized: service.rejectUnauthorized,
+    },
+  ];
+}
+
+methods.forEach(m => {
+  KyRequester[m] = async function(service, endpoint, options) {
+    try {
+      const response = await Ky[m](...defaultRequest(service, endpoint, options));
+      const { status } = response;
+      const headers = responseHeadersAsObject(response);
+      let body = await response.json();
+
+      if (typeof body === 'object') body = body || {};
+
+      return { body, headers, status };
+    } catch(e) {
+      console.error(e)
+      console.error(...defaultRequest(service, endpoint, options))
+      throw(e)
+    }
+  };
+});
+
+export { KyRequester };