@mimik/oauth-helper 1.4.5 → 1.9.6

package/.eslintrc

@@ -1,17 +1,34 @@
-// Use this file as a starting point for your project's .eslintrc.
-// Copy this file, and add rule overrides as needed.
 {
+  "plugins": [
+    "@mimik/document-env",
+    "@mimik/dependencies"
+  ],
   "env": {
     "node": true
   },
+  "parserOptions": {
+    "ecmaVersion": 2020
+  },
   "extends": "airbnb",
   "rules": {
+    "import/no-extraneous-dependencies": ["error", {"devDependencies": true}],
     "brace-style": [1, "stroustrup", {"allowSingleLine": true}],
     "no-confusing-arrow": [0], // arrow isnt confusing
     "max-len": [1, 180, { "ignoreComments": true }],
     "linebreak-style": 0,
     "quotes": [1, "single"],
-    "semi": [1, "always"]
+    "semi": [1, "always"],
+    "no-process-env": ["error"],
+    "@mimik/document-env/validate-document-env": 2,
+    "@mimik/dependencies/case-sensitive": 2,
+    "@mimik/dependencies/no-cycles": 2,
+    "@mimik/dependencies/no-unresolved": 2,
+    "@mimik/dependencies/require-json-ext": 2
+  },
+  "settings":{
+    "react": {
+      "version": "latest"
+    }
   },
   "globals": {
     "module": true,

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npm run commit-ready

package/.husky/pre-push

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npm run test

package/.nycrc

@@ -0,0 +1,4 @@
+{
+  "exclude": ["gulpfile.js"],
+  "reporter": ["lcov", "text"]
+}

package/Gulpfile.js

@@ -5,29 +5,37 @@ const gulp = require('gulp');
 const eslint = require('gulp-eslint');
 const git = require('gulp-git');
 const jsdoc2md = require('jsdoc-to-markdown');
+const mocha = require('gulp-spawn-mocha');
 
 const files = [
   'index.js',
   'Gulpfile.js',
-  'test/*.spec.js',
+  'test/**.js',
   'lib/**.js',
 ];
 
-const docs = (done) => {
+const createDocs = (done) => {
   jsdoc2md.render({ files: 'index.js' })
-    .then(output => fs.writeFileSync('README.md', output))
-    .catch(err => log.error('docs creation failed:', err.message));
-  return done();
+    .then((output) => fs.writeFileSync('README.md', output))
+    .catch((err) => log.error('docs creation failed:', err.message))
+    .finally(() => done());
 };
 
 const lint = () => gulp.src(files)
   .pipe(eslint({}))
-  .pipe(eslint.format())
-  .pipe(eslint.failOnError());
+  .pipe(eslint.format());
 
 const add = () => gulp.src('README.md')
   .pipe(git.add({ quiet: true }));
 
-gulp.task('docs', docs);
+const test = () => gulp.src(['test/*.spec.js'])
+  .pipe(mocha({
+    reporter: 'mochawesome',
+    exit: true,
+  }));
+
+const docs = gulp.series(createDocs, add);
+
 gulp.task('lint', lint);
-gulp.task('add', add);
+gulp.task('docs', docs);
+gulp.task('test', test);

package/README.md

@@ -26,6 +26,7 @@ const oauthHelper = require('@mimik/oauth-helper');
         * [~rpAuth(type, options)](#module_oauth-helper..rpAuth) ⇒ <code>Promise</code>
         * [~authProfile(method, id, correlationId)](#module_oauth-helper..authProfile) ⇒ <code>Promise</code>
     * _callback_
+        * [~apiKeySecurityHelper(request, definitions, apiKey, next)](#module_oauth-helper..apiKeySecurityHelper)
         * [~apiTokenSecurityHelper(request, definitions, scopes, next)](#module_oauth-helper..apiTokenSecurityHelper)
         * [~apiTokenAdminSecurityHelper(request, definitions, scopes, next)](#module_oauth-helper..apiTokenAdminSecurityHelper)
 
@@ -41,6 +42,15 @@ Make an authorized request.
 
 - <code>Promise</code> Will throw the same error than [request-promise](https://www.npmjs.com/package/request-promise).
 
+The property `token` may be added to options, in order to set up how the token is retrieved from the token manager. The structure is:
+```
+{
+   "retry": "object to specify how the retry to the token manager will be done. similar to rp-retry retry property",
+   "customerName": "name of the customer for which the token is entended for, see mST API",
+   "cluster": "to set the token to be a cluster token"
+}
+````
+
 **Requires**: <code>module:@mimik/sumologic-winston-logger</code>  
 **Fulfil**: <code>object</code> - Response of the [request-promise](https://www.npmjs.com/package/request-promise) request.  
 
@@ -59,7 +69,7 @@ Make an authProfile request to mID.
 **Category**: async  
 **Throws**:
 
-- <code>Promise</code> Will throw an error is the request fails.
+- <code>Promise</code> Will throw a rich error is the request fails or an error if the id is not identified
 
 **Requires**: <code>module:@mimik/sumologic-winston-logger</code>  
 **Fulfil**: <code>object</code> The response of the request made to `mID`.  
@@ -70,6 +80,21 @@ Make an authProfile request to mID.
 | id | <code>string</code> | `UserId` to associated witht the request. |
 | correlationId | <code>UUID.&lt;string&gt;</code> | CorrelationId to associated with the request. |
 
+<a name="module_oauth-helper..apiKeySecurityHelper"></a>
+
+### oauth-helper~apiKeySecurityHelper(request, definitions, apiKey, next)
+Validate the request by checking the apiKey. To be used for `apikey`;
+
+**Kind**: inner method of [<code>oauth-helper</code>](#module_oauth-helper)  
+**Category**: callback  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| request | <code>object</code> | The request with a token in the header. |
+| definitions | <code>object</code> | Swagger security definitions to compare with. |
+| apiKey | <code>Array.&lt;string&gt;</code> | APIky extracted from the defined location. |
+| next | [<code>requestCallback</code>](#requestCallback) | The callback that handles the response. The validation adds the following properties to the request: - apiKey Only the header location is allowed. |
+
 <a name="module_oauth-helper..apiTokenSecurityHelper"></a>
 
 ### oauth-helper~apiTokenSecurityHelper(request, definitions, scopes, next)
@@ -83,7 +108,7 @@ Validate the request by inspecting the token. To be used for `system` and `user`
 | request | <code>object</code> | The request with a token in the header. |
 | definitions | <code>object</code> | Swagger security definitions to compare with. |
 | scopes | <code>Array.&lt;string&gt;</code> | List of swagger scopes associated whith the requested endpoint. |
-| next | [<code>requestCallback</code>](#requestCallback) | The callback that handles the response. The validation adds the following properties to the request: - in case of 'system' token: 'clientId', 'tokenType', 'customer', 'onBehlaf'. - in case of 'user' token: userId, appId, onBehalfId, 'onBehalf'. |
+| next | [<code>requestCallback</code>](#requestCallback) | The callback that handles the response. The validation adds the following properties to the request: - in case of 'system' token: 'clientId', 'tokenType', 'customer', 'onBehlaf'. If the token is a cluster token the property 'cluster' is set to true. - in case of 'user' token: userId, appId, onBehalfId, 'onBehalf'. |
 
 <a name="module_oauth-helper..apiTokenAdminSecurityHelper"></a>
 

package/index.js

@@ -1,7 +1,13 @@
+const Promise = require('bluebird');
 const jwt = require('jsonwebtoken');
-const rp = require('request-promise');
 const _ = require('lodash');
+
+const { rpRetry } = require('@mimik/request-retry');
 const logger = require('@mimik/sumologic-winston-logger');
+const { getRichError } = require('@mimik/response-helper');
+const { TOKEN_PARAMS } = require('@mimik/swagger-helper');
+
+Promise.config({ cancellation: true });
 /**
  * @module oauth-helper
  * @example
@@ -12,9 +18,14 @@ const TOKEN_REFRESH_TOLERANCE = 900; // in seconds
 const ON_BEHALF = 'onBehalf';
 const SUB_ADMIN = 'subAdmin';
 const ADMIN = 'admin';
+const USER = 'user';
 const NO_GENERIC = 'noGeneric';
-const APPLICATION = 'application';
+// const APPLICATION = 'application';
 const IMPLICIT = 'implicit';
+const CLIENT = '@clients';
+const AUTHORIZATION = 'authorization';
+const HEADER = 'header';
+const CLUSTER = 'cluster';
 
 const tokens = {};
 
@@ -29,45 +40,47 @@ const createToken = (value) => {
     value,
     exp: jwt.decode(value).exp,
   };
-
   return token;
 };
 
 module.exports = (config) => {
-  const jwtOptions = (flow) => {
-    if (flow === IMPLICIT) { // user flow
+  const { implicit, server, generic } = config.security;
+  const jwtOptions = (fl) => {
+    if (fl === IMPLICIT) { // user flow
       return {
-        audience: (config.security.implicit && config.security.implicit.audience) || config.security.server.audience,
-        issuer: (config.security.implicit && config.security.implicit.issuer) || config.security.server.issuer,
+        audience: (implicit && implicit.audience) || server.audience,
+        issuer: (implicit && implicit.issuer) || server.issuer,
       };
     }
-    if (flow === APPLICATION) { // server to server flow
-      return {
-        audience: (config.security.generic.audience === NO_GENERIC) ? config.security.server.audience : config.security.generic.audience,
-        issuer: config.security.server.issuer,
-        // subject: `${config.serverSettings.id}@clients`,
-      };
-    }
-    throw new Error(`flow ${flow} not implemented`);
+    // server to server or admin flow (application)
+    return {
+      audience: (generic.audience === NO_GENERIC) ? server.audience : generic.audience,
+      issuer: server.issuer,
+      // subject: `${config.serverSettings.id}@clients`,
+    };
   };
-  const keys = (flow) => {
-    if (flow === IMPLICIT) {
-      return (config.security.implicit && config.security.implicit.key)
-        || ((config.security.generic.key === NO_GENERIC) ? config.security.server.accessKey : config.security.generic.key);
+  const keys = (fl) => {
+    if (fl === IMPLICIT) { // user flow
+      return (implicit && implicit.key)
+        || ((generic.key === NO_GENERIC) ? server.accessKey : generic.key);
     }
-    if (flow === APPLICATION) {
-      return (config.security.generic.key === NO_GENERIC) ? config.security.server.accessKey : config.security.generic.key;
-    }
-    throw new Error(`flow ${flow} not implemented`);
+    // server to server or admin flow (application)
+    return (generic.key === NO_GENERIC) ? server.accessKey : generic.key;
   };
   const checkHeaders = (headers) => {
     if (!headers) {
       throw new Error('missing header');
     }
-    if (!headers.authorization) {
-      throw new Error('missing authorization header');
+    const authNames = Object.keys(headers).filter((key) => key.toLowerCase() === AUTHORIZATION);
+    const authNamesLength = authNames.length;
+
+    if (authNamesLength === 0) {
+      throw new Error(`missing ${AUTHORIZATION} header`);
+    }
+    if (authNamesLength !== 1) {
+      throw new Error(`duplicated ${AUTHORIZATION} header`);
     }
-    const auth = headers.authorization.split(' ');
+    const auth = headers[authNames[0]].split(' ');
 
     if ((auth[0] !== 'bearer' && auth[0] !== 'Bearer') || auth.length !== 2) {
       throw new Error(`authorization type incorrect: ${auth[0]}`);
@@ -84,53 +97,60 @@ module.exports = (config) => {
       const intersects = _.intersection(currentScopes, defScopes);
 
       if (intersects.length === 0) {
-        throw new Error(`incorrect scopes: ${currentScopes}`);
+        throw new Error(`incorrect scopes: ${tokenScopes}`);
       }
 
-      if (_.find(intersects, scope => scope.split(':')[0] === ON_BEHALF)) {
+      if (_.find(intersects, (scope) => scope.split(':')[0] === ON_BEHALF)) {
         return true;
       }
     }
     return false;
   };
 
-  const getToken = (type, correlationId) => {
+  const getToken = (type, origin, options, correlationId) => {
     const tokenOptions = {
       method: 'POST',
-      uri: config.security.server.issuer,
-      json: true,
+      url: server.issuer,
     };
+
+    if (correlationId) tokenOptions.headers = { 'x-correlation-id': correlationId };
     const getCredential = {
-      client_id: config.security.server.id,
-      client_secret: config.security.server.secret,
+      client_id: server.id,
+      client_secret: server.secret,
       audience: config.dependencies[type].audience,
       grant_type: 'client_credentials',
     };
 
+    if (options) {
+      if (options.customerName) getCredential.customer_name = options.customerName;
+      if (options.retry) tokenOptions.retry = options.retry;
+      if (options.cluster) getCredential.type = CLUSTER;
+    }
     if (!tokens[type]) tokens[type] = {};
-    if (valid(tokens[type].accessToken)) return Promise.resolve(tokens[type].accessToken.value);
-    if (valid(tokens[type].refreshToken)) {
-      logger.silly('valid refresh_token, refresh_token', { type }, correlationId);
+    if (!tokens[type][origin]) tokens[type][origin] = {};
+    if (valid(tokens[type][origin].accessToken)) return Promise.resolve(tokens[type][origin].accessToken.value);
+    if (valid(tokens[type][origin].refreshToken)) {
+      logger.silly('valid refresh_token, refresh_token', { type, origin }, correlationId);
       tokenOptions.body = {
-        refresh_token: tokens[type].refreshToken.value,
+        refresh_token: tokens[type][origin].refreshToken.value,
         grant_type: 'refresh_token',
       };
     }
     else {
-      logger.silly('invalid refresh_token, client_credentials', { type }, correlationId);
+      logger.silly('invalid refresh_token, client_credentials', { type, origin }, correlationId);
       tokenOptions.body = getCredential;
     }
-    return rp(tokenOptions).catch((err) => {
+    return rpRetry(tokenOptions).catch((err) => {
       if (err.statusCode !== 400 || tokenOptions.body.grant_type === 'client_credentials') {
         throw err;
       }
       logger.silly('moving from refresh_token to client_credential', { error: err.message }, correlationId);
       tokenOptions.body = getCredential;
-      return rp(tokenOptions);
+      return rpRetry(tokenOptions);
     }).then((response) => {
-      tokens[type].accessToken = createToken(response.data.access_token);
-      tokens[type].refreshToken = createToken(response.data.refresh_token);
-      return tokens[type].accessToken.value;
+      tokens[type][origin].accessToken = createToken(response.data.access_token);
+      tokens[type][origin].refreshToken = createToken(response.data.refresh_token);
+      return tokens[type][origin].accessToken.value;
     });
   };
 
@@ -145,29 +165,42 @@ module.exports = (config) => {
    * @return {Promise}.
    * @fulfil {object} - Response of the [request-promise](https://www.npmjs.com/package/request-promise) request.
    * @throws {Promise} Will throw the same error than [request-promise](https://www.npmjs.com/package/request-promise).
+   *
+   * The property `token` may be added to options, in order to set up how the token is retrieved from the token manager. The structure is:
+   * ```
+   * {
+   *    "retry": "object to specify how the retry to the token manager will be done. similar to rp-retry retry property",
+   *    "customerName": "name of the customer for which the token is entended for, see mST API",
+   *    "cluster": "to set the token to be a cluster token"
+   * }
+   * ````
    */
   const rpAuth = (type, options) => {
-    if (!type) return Promise.reject(new Error(`rpAuth type non existent for ${options.method || 'GET'} on ${options.url || options.uri}`));
+    const enteredUrl = options.uri || options.url; // uri takes precedence over url in request-promise, conserving the order
+    let url;
+
+    if (!type) return Promise.reject(new Error(`rpAuth type non existent for ${options.method || 'GET'} on ${enteredUrl}`));
     if (!config.dependencies[type]) return Promise.reject(new Error(`type ${type} used in rpAuth with no dependencies`));
+    if (!options.url && !options.uri) return Promise.reject(new Error('uri or url non existent'));
+    try { url = new URL(enteredUrl); }
+    catch (err) { return Promise.reject(new Error(`invalid url address: ${enteredUrl}: ${err.message}`)); }
     const correlationId = (options.headers && options.headers['x-correlation-id']);
 
-    return getToken(type, correlationId)
+    return getToken(type, url.origin, options.token, correlationId)
       .then((token) => {
         const opts = options;
 
         if (!opts.headers) opts.headers = {};
         opts.headers.authorization = `Bearer ${token}`;
-        opts.simple = true; // make sure that we use the simple mode
-        return rp(opts)
+        return rpRetry(opts)
           .catch((err) => {
             if (err.statusCode === 403) {
               logger.warn('got a unauthorized request, retrying', { error: err.message, type }, correlationId);
               tokens[type].accessToken = null;
-              return getToken(type, correlationId)
+              return getToken(type, options.uri || options.url, options.token, correlationId)
                 .then((newToken) => {
-                  if (!opts.headers) opts.headers = {};
                   opts.headers.authorization = `Bearer ${newToken}`;
-                  return rp(opts);
+                  return rpRetry(opts);
                 });
             }
             throw err;
@@ -175,6 +208,33 @@ module.exports = (config) => {
       });
   };
 
+  /**
+   * Validate the request by checking the apiKey. To be used for `apikey`;
+   *
+   * @function apiKeySecurityHelper
+   * @category callback
+   * @param {object} request - The request with a token in the header.
+   * @param {object} definitions - Swagger security definitions to compare with.
+   * @param {string[]} apiKey - APIky extracted from the defined location.
+   * @param {requestCallback} next - The callback that handles the response.
+   *
+   * The validation adds the following properties to the request:
+   * - apiKey
+   * Only the header location is allowed.
+   */
+  const apiKeySecurityHelper = (request, definitions, apiKey, next) => {
+    if (definitions.in !== HEADER) {
+      next(new Error(`invalid location: only ${HEADER} is accepted`));
+      return;
+    }
+    if (config.security.apiKeys.includes(apiKey)) {
+      request.apiKey = apiKey;
+      next(null);
+      return;
+    }
+    next(new Error('invalid API key'));
+  };
+
   /**
    * Validate the request by inspecting the token. To be used for `system` and `user` token.
    *
@@ -186,11 +246,12 @@ module.exports = (config) => {
    * @param {requestCallback} next - The callback that handles the response.
    *
    * The validation adds the following properties to the request:
-   * - in case of 'system' token: 'clientId', 'tokenType', 'customer', 'onBehlaf'.
+   * - in case of 'system' token: 'clientId', 'tokenType', 'customer', 'onBehlaf'. If the token is a cluster token the property 'cluster' is set to true.
    * - in case of 'user' token: userId, appId, onBehalfId, 'onBehalf'.
    */
   const apiTokenSecurityHelper = (request, definitions, scopes, next) => {
     let authToken;
+    const { flow } = definitions;
 
     try { authToken = checkHeaders(request.headers); }
     catch (err) {
@@ -207,10 +268,19 @@ module.exports = (config) => {
       next(new Error('invalid token: wrong type'));
       return;
     }
-    try { jwt.verify(authToken, keys(definitions.flow), jwtOptions(definitions.flow)); }
+    try { jwt.verify(authToken, keys(flow), jwtOptions(flow)); }
     catch (err) {
-      next(err);
-      return;
+      if (flow !== IMPLICIT && generic.previousKey) { // backward compatibility
+        try { jwt.verify(authToken, generic.previousKey, jwtOptions(flow)); }
+        catch (secondErr) {
+          next(secondErr);
+          return;
+        }
+      }
+      else {
+        next(err);
+        return;
+      }
     }
     let onBehalfOption = false;
 
@@ -219,25 +289,24 @@ module.exports = (config) => {
       next(errScopes);
       return;
     }
-    if (onBehalfOption) request.onBehalf = true;
+    if (onBehalfOption) request[TOKEN_PARAMS.onBehalf] = true;
     if (definitions.flow === IMPLICIT) {
-      if (token.sub) request.userId = token.sub;
-      if (token.azp) request.appId = token.azp;
+      if (token.sub) request[TOKEN_PARAMS.userId] = token.sub;
+      if (token.azp) request[TOKEN_PARAMS.appId] = token.azp;
       if (token.may_act && token.may_act.sub) {
-        request.onBehalfId = token.sub;
-        request.userId = token.may_act.sub;
+        request[TOKEN_PARAMS.onBehalfId] = token.sub;
+        request[TOKEN_PARAMS.userId] = token.may_act.sub;
       }
+      request.tokenType = USER;
       next(null);
       return;
     }
-    if (definitions.flow === APPLICATION) {
-      if (token.sub) request.clientId = token.sub;
-      if (token.subType) request.tokenType = token.subType;
-      if (token.cust) request.customer = token.cust;
-      next(null);
-      return;
-    }
-    next(new Error(`flow ${definitions.flow} not implemented`));
+    // server to server or admin flow (application)
+    if (token.sub) request[TOKEN_PARAMS.clientId] = token.sub;
+    if (token.subType) request[TOKEN_PARAMS.tokenType] = token.subType;
+    if (token.cust) request[TOKEN_PARAMS.customer] = token.cust;
+    if (token.type === CLUSTER) request[TOKEN_PARAMS.cluster] = true;
+    next(null);
   };
 
   /**
@@ -254,6 +323,7 @@ module.exports = (config) => {
    */
   const apiTokenAdminSecurityHelper = (request, definitions, scopes, next) => {
     let authToken;
+    const { flow } = definitions;
 
     try { authToken = checkHeaders(request.headers); }
     catch (err) {
@@ -272,14 +342,20 @@ module.exports = (config) => {
       return;
     }
     try {
-      jwt.verify(authToken, config.security.generic.key, {
-        audience: config.security.generic.audience,
-        issuer: config.security.server.issuer,
-      });
+      jwt.verify(authToken, keys(flow), jwtOptions(flow));
     }
     catch (err) {
-      next(err);
-      return;
+      if (generic.previousKey) { // backward compatibility
+        try { jwt.verify(authToken, generic.previousKey, jwtOptions(flow)); }
+        catch (secondErr) {
+          next(secondErr);
+          return;
+        }
+      }
+      else {
+        next(err);
+        return;
+      }
     }
     try { checkScopes(token.scope, scopes); }
     catch (errScopes) {
@@ -292,13 +368,13 @@ module.exports = (config) => {
         return;
       }
     }
-    else if (token.sub !== `${config.security.admin.externalId}@clients`) {
+    else if (token.sub !== `${config.security.admin.externalId}${CLIENT}`) {
       next(new Error(`jwt subject invalid: ${token.sub}`));
       return;
     }
-    if (token.subType) request.tokenType = token.subType;
-    if (token.sub) request.clientId = token.sub;
-    if (token.cust) request.customer = token.cust;
+    if (token.subType) request[TOKEN_PARAMS.tokenType] = token.subType;
+    if (token.sub) request[TOKEN_PARAMS.clientId] = token.sub;
+    if (token.cust) request[TOKEN_PARAMS.customer] = token.cust;
     next(null);
   };
 
@@ -313,25 +389,31 @@ module.exports = (config) => {
    * @param {UUID<string>} correlationId - CorrelationId to associated with the request.
    * @return {Promise}.
    * @fulfil {object} The response of the request made to `mID`.
-   * @throws {Promise} Will throw an error is the request fails.
+   * @throws {Promise} Will throw a rich error is the request fails or an error if the id is not identified
    */
-  const authProfile = (method, id, correlationId) => rpAuth('mID', {
-    method,
-    uri: `${config.dependencies.mID.url}/users/${id}`,
-    headers: {
-      'x-correlation-id': correlationId,
-    },
-    json: true,
-  }).catch((err) => {
-    if (err.statusCode === 400 && method === 'DELETE') {
-      logger.warn('profile without authprofile', { id, error: err.message }, correlationId);
-      return;
-    }
-    throw new Error(err.message);
-  });
+  const authProfile = (method, id, correlationId) => {
+    if (!id) return Promise.reject(new Error('Id has to be defined'));
+    return rpAuth('mID', {
+      method,
+      uri: `${config.dependencies.mID.url}/users/${id}`,
+      headers: {
+        'x-correlation-id': correlationId,
+      },
+      json: true,
+    }).catch((err) => {
+      const error = getRichError(err.statusCode, 'could perform operation on identity server', { method, id }, err);
+
+      if (error.statusCode === 400 && method === 'DELETE') {
+        logger.warn('profile without authprofile', { id, error }, correlationId);
+        return;
+      }
+      throw error;
+    });
+  };
 
   return {
     rpAuth,
+    apiKeySecurityHelper,
     apiTokenSecurityHelper,
     apiTokenAdminSecurityHelper,
     authProfile,

package/manual-test/testUrl.js

@@ -0,0 +1,10 @@
+const rp = require('request-promise');
+
+const options = {
+	method: 'GET',
+	url: 'http://google.com',
+	uri: 'http//google.com',
+	json: true,
+};
+
+rp(options).then(() => console.log('ok')).catch((err) => console.log(err));