Add types for responses.

Author: mcrowe

lib/cookie.d.ts

@@ -1,6 +1,6 @@
-declare var _default: {
+declare const _default: {
     serialize: (object: any) => string;
-    parse: (string: string) => {};
+    parse: (string: string | undefined) => {};
     assign: (string: any, key: any, value: any) => string;
     parseSetString: (string: string) => string;
 };

lib/index.d.ts

@@ -1,18 +1,29 @@
-export interface Map {
+import { IResult } from '@mcrowe/result';
+export interface IMap {
     [key: string]: string;
 }
-declare class HeadlessBrowser {
-    headers: Map;
-    constructor(headers?: Map);
-    get(opts: any): Promise<any>;
-    setHeaders(headers: Map): void;
+export interface IResponseHeaders {
+    'set-cookie'?: string[];
+    'content-type'?: string;
+}
+export interface IHttpResponse {
+    statusCode: number;
+    body: string;
+    headers: IResponseHeaders;
+}
+export declare type IRequestHeaders = IMap;
+export declare type IHttpResult = IResult<IHttpResponse>;
+export default class HeadlessBrowser {
+    headers: IRequestHeaders;
+    constructor(headers?: IRequestHeaders);
+    get(opts: any): Promise<IHttpResult>;
+    setHeaders(headers: IRequestHeaders): void;
     setHeader(key: string, value: string): void;
     setCookie(key: string, value: string): void;
-    getCookies(): Map;
-    setCookies(cookies: Map | string): any;
+    getCookies(): IMap;
+    setCookies(cookies: IMap | string): any;
     getUserAgent(): string;
     setUserAgent(value: string): void;
     setAcceptEncoding(value: string): void;
-    setCookiesFromResponse(res: any): void;
+    setCookiesFromResponse(res: IHttpResponse): void;
 }
-export default HeadlessBrowser;

lib/index.js

@@ -1,15 +1,24 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const result_1 = require("@mcrowe/result");
 const Request = require("request");
 const cookie_1 = require("./cookie");
 function getRequest(opts) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve, _reject) => {
         Request.get(opts, (err, data) => {
             if (err) {
-                reject(err);
+                resolve(result_1.Result.Error(err.message));
             }
             else {
-                resolve(data);
+                resolve(result_1.Result.OK(data));
             }
         });
     });
@@ -19,10 +28,13 @@ class HeadlessBrowser {
         this.headers = Object.assign({}, headers);
     }
     get(opts) {
-        const defaults = { headers: this.headers };
-        opts = Object.assign({}, defaults, opts);
-        return getRequest(opts).then((res) => {
-            this.setCookiesFromResponse(res);
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaults = { headers: this.headers };
+            opts = Object.assign({}, defaults, opts);
+            const res = yield getRequest(opts);
+            if (res.ok) {
+                this.setCookiesFromResponse(res.data);
+            }
             return res;
         });
     }

package.json

@@ -6,25 +6,24 @@
   "license": "ISC",
   "repository": "https://github.com/mcrowe/headless-browser",
   "scripts": {
-    "test": "./node_modules/mocha/bin/mocha -u qunit --recursive -r ./node_modules/ts-node/register test/*",
-    "build": "./node_modules/typescript/bin/tsc"
+    "test": "mocha -u qunit --recursive -r ./node_modules/ts-node/register test/*",
+    "build": "tsc",
+    "watch": "tsc -w"
   },
   "main": "lib/index.js",
   "typings": "lib/index",
   "files": [
     "lib/"
   ],
   "dependencies": {
-    "@types/bluebird": "^3.5.2",
-    "@types/request": "0.0.42",
-    "bluebird": "^3.4.7",
+    "@mcrowe/result": "0.0.2",
     "request": "^2.79.0"
   },
   "devDependencies": {
     "@types/mocha": "^2.2.39",
     "@types/node": "^7.0.12",
     "mocha": "^3.2.0",
-    "ts-node": "^2.1.0",
-    "typescript": "^2.1.4"
+    "ts-node": "^3.1.0",
+    "typescript": "^2.4.1"
   }
 }

src/cookie.ts

@@ -12,7 +12,7 @@ function serialize(object) {
 }
 
 
-function parse(string: string) {
+function parse(string: string | undefined) {
   if (!string) {
     return {}
   }

src/index.ts

@@ -1,43 +1,65 @@
+import { Result, IResult } from '@mcrowe/result'
 import Request = require('request')
 import Cookie from './cookie'
 
 
-function getRequest(opts): Promise<any> {
-  return new Promise((resolve, reject) => {
+export interface IMap {
+  [key: string]: string
+}
+
+
+export interface IResponseHeaders {
+  'set-cookie'?: string[]
+  'content-type'?: string
+}
+
+
+export interface IHttpResponse {
+  statusCode: number
+  body: string
+  headers: IResponseHeaders
+}
+
+export type IRequestHeaders = IMap
+
+
+export type IHttpResult = IResult<IHttpResponse>
+
+
+function getRequest(opts): Promise<IHttpResult> {
+  return new Promise((resolve, _reject) => {
     Request.get(opts, (err, data) => {
       if (err) {
-        reject(err)
+        resolve( Result.Error(err.message) )
       } else {
-        resolve(data)
+        resolve( Result.OK(data) )
       }
     })
   })
 }
 
 
-export interface Map {
-  [key: string]: string
-}
-
-
-class HeadlessBrowser {
+export default class HeadlessBrowser {
 
-  headers: Map
+  headers: IRequestHeaders
 
-  constructor(headers: Map = {}) {
+  constructor(headers: IRequestHeaders = {}) {
     this.headers = { ...headers }
   }
 
-  get(opts) {
+  async get(opts): Promise<IHttpResult> {
     const defaults = {headers: this.headers}
     opts = Object.assign({}, defaults, opts)
-    return getRequest(opts).then((res) => {
-      this.setCookiesFromResponse(res)
-      return res
-    })
+    const res = await getRequest(opts)
+
+    if (res.ok) {
+      this.setCookiesFromResponse(res.data)
+    }
+
+    return res
   }
 
-  setHeaders(headers: Map) {
+  setHeaders(headers: IRequestHeaders) {
     this.headers = headers
   }
 
@@ -50,11 +72,11 @@ class HeadlessBrowser {
     this.setHeader('Cookie', cookie)
   }
 
-  getCookies(): Map {
+  getCookies(): IMap {
     return Cookie.parse(this.headers['Cookie'])
   }
 
-  setCookies(cookies: Map | string) {
+  setCookies(cookies: IMap | string) {
     if (typeof cookies == 'string') {
       return this.setCookies(Cookie.parse(cookies))
     } else {
@@ -76,7 +98,7 @@ class HeadlessBrowser {
     this.setHeader('Accept-Encoding', value)
   }
 
-  setCookiesFromResponse(res) {
+  setCookiesFromResponse(res: IHttpResponse) {
     const resCookies = res.headers['set-cookie']
 
     if (resCookies) {
@@ -85,7 +107,4 @@ class HeadlessBrowser {
     }
   }
 
-}
-
-
-export default HeadlessBrowser
+}

test/index.test.ts

@@ -11,7 +11,11 @@ test('set cookies from response', () => {
   const cookies = ['NID']
 
   return browser.get({uri: 'http://www.google.com'}).then(res => {
-    assert.equal(200, res.statusCode)
-    assert.deepEqual(cookies, Object.keys(browser.getCookies()))
+    assert(res.ok)
+
+    if (res.ok) {
+      assert.equal(200, res.data.statusCode)
+      assert.deepEqual(cookies, Object.keys(browser.getCookies()))
+    }
   })
 })

tsconfig.json

@@ -3,7 +3,8 @@
     "module": "commonjs",
     "declaration": true,
     "outDir": "lib/",
-    "target": "es2015"
+    "target": "es2015",
+    "strictNullChecks": true
   },
   "include": [
     "src/**/*"