Merge remote-tracking branch 'origin/sagonzal/device-code' into msal-node-logging

Author: sameerag

lib/msal-common/package-lock.json

@@ -84,7 +84,7 @@
         "sinon": "^7.5.0",
         "tslib": "^1.10.0",
         "tslint": "^5.20.0",
-        "typescript": "^3.6.4"
+        "typescript": "^3.7.5"
     },
     "dependencies": {
         "debug": "^4.1.1"

lib/msal-common/package.json

@@ -122,7 +122,6 @@ export abstract class Authority {
 
     constructor(authority: string, networkInterface: INetworkModule) {
         this.canonicalAuthority = authority;
-        console.log("Authority constructor: ", authority);
 
         this._canonicalAuthority.validateAsUri();
         this.networkInterface = networkInterface;

lib/msal-common/src/authority/Authority.ts

@@ -7,7 +7,7 @@ import { BaseClient } from "./BaseClient";
 import { AuthorizationCodeUrlRequest } from "../request/AuthorizationCodeUrlRequest";
 import { AuthorizationCodeRequest } from "../request/AuthorizationCodeRequest";
 import { Authority } from "../authority/Authority";
-import { ServerParamsGenerator } from "../server/ServerParamsGenerator";
+import { RequestUtils } from "../utils/RequestUtils";
 import { RequestValidator } from "../request/RequestValidator";
 import { GrantType } from "../utils/Constants";
 import { Configuration } from "../config/Configuration";
@@ -30,16 +30,20 @@ export class AuthorizationCodeClient extends BaseClient {
     }
 
     /**
-     * Creates a url for logging in a user.
-     *  - scopes added by default: openid, profile and offline_access.
-     *  - performs validation of the request parameters.
+     * Creates the URL of the authorization request letting the user input credentials and consent to the
+     * application. The URL target the /authorize endpoint of the authority configured in the
+     * application object.
+     *
+     * Once the user inputs their credentials and consents, the authority will send a response to the redirect URI
+     * sent in the request and should contain an authorization code, which can then be used to acquire tokens via
+     * acquireToken(AuthorizationCodeRequest)
      * @param request
      */
     async getAuthCodeUrl(request: AuthorizationCodeUrlRequest): Promise<string> {
 
         const authority: Authority = await this.createAuthority(request && request.authority);
         const queryParams: Map<string, string> = this.generateAuthCodeUrlParams(request);
-        const queryString = ServerParamsGenerator.createQueryString(queryParams);
+        const queryString = RequestUtils.createQueryString(queryParams);
         return authority.authorizationEndpoint + "?" + queryString;
     }
 
@@ -59,27 +63,25 @@ export class AuthorizationCodeClient extends BaseClient {
 
     /**
      * Executes POST request to token endpoint
-     * @param tokenEndPoint
-     * @param body
-     * @param headers
+     * @param authority
+     * @param request
      */
-    private async executeTokenRequest(authority: Authority, requestParameters: AuthorizationCodeRequest): Promise<string> {
+    private async executeTokenRequest(authority: Authority, request: AuthorizationCodeRequest): Promise<string> {
 
-        const tokenParameters: Map<string, string> = this.generateAuthCodeParams(requestParameters);
-        const headers: Map<string, string> = new Map<string, string>();
+        const tokenParameters: Map<string, string> = this.generateAuthCodeParams(request);
+        const requestBody = RequestUtils.createQueryString(tokenParameters);
+        const headers: Map<string, string> = this.createDefaultTokenRequestHeaders();
 
         let acquiredTokenResponse;
         try {
-            acquiredTokenResponse = this.networkClient.sendPostRequestAsync<string>(
+            acquiredTokenResponse = this.executePostToTokenEndpoint(
                 authority.tokenEndpoint,
-                {
-                    body: ServerParamsGenerator.createQueryString(tokenParameters),
-                    headers: this.createDefaultTokenRequestHeaders()
-                }
-            );
+                requestBody,
+                headers);
+
             return acquiredTokenResponse;
         } catch (error) {
-            console.log(error.response.data);
+            console.log(error.response.data); // TODO use logger
             return error.response.data;
         }
     }
@@ -91,89 +93,92 @@ export class AuthorizationCodeClient extends BaseClient {
     private generateAuthCodeParams(request: AuthorizationCodeRequest) : Map<string, string> {
         const paramsMap: Map<string, string> = new Map<string, string>();
 
-        ServerParamsGenerator.addClientId(paramsMap, this.config.authOptions.clientId);
+        RequestUtils.addClientId(paramsMap, this.config.authOptions.clientId);
 
         // validate and add scopes
         const scopes = RequestValidator.validateAndGenerateScopes(
             request.scopes,
             this.config.authOptions.clientId
         );
-        ServerParamsGenerator.addScopes(paramsMap, scopes);
+        RequestUtils.addScopes(paramsMap, scopes);
 
         // validate the redirectUri (to be a non null value)
         RequestValidator.validateRedirectUri(request.redirectUri);
-        ServerParamsGenerator.addRedirectUri(paramsMap, request.redirectUri);
+        RequestUtils.addRedirectUri(paramsMap, request.redirectUri);
 
         // add code: user set, not validated
-        ServerParamsGenerator.addAuthorizationCode(paramsMap, request.code);
+        RequestUtils.addAuthorizationCode(paramsMap, request.code);
 
         // add code_verifier if passed
         if (request.codeVerifier) {
-            ServerParamsGenerator.addCodeVerifier(paramsMap, request.codeVerifier);
+            RequestUtils.addCodeVerifier(paramsMap, request.codeVerifier);
         }
 
-        ServerParamsGenerator.addGrantType(paramsMap, GrantType.AUTHORIZATION_CODE_GRANT);
+        RequestUtils.addGrantType(paramsMap, GrantType.AUTHORIZATION_CODE_GRANT);
 
         return paramsMap;
     }
 
     /**
      * This API validates the `AuthorizationCodeUrlRequest` and creates a URL
      * @param request
-     * @param config
      */
     private generateAuthCodeUrlParams(request: AuthorizationCodeUrlRequest): Map<string, string>{
         const paramsMap = new Map<string, string>();
 
-        ServerParamsGenerator.addClientId(paramsMap, this.config.authOptions.clientId);
+        RequestUtils.addClientId(paramsMap, this.config.authOptions.clientId);
 
         // validate and add scopes
         const scopes = RequestValidator.validateAndGenerateScopes(
             request.scopes,
             this.config.authOptions.clientId
         );
-        ServerParamsGenerator.addScopes(paramsMap, scopes);
+        RequestUtils.addScopes(paramsMap, scopes);
 
         // validate the redirectUri (to be a non null value)
         RequestValidator.validateRedirectUri(request.redirectUri);
-        ServerParamsGenerator.addRedirectUri(paramsMap, request.redirectUri);
+        RequestUtils.addRedirectUri(paramsMap, request.redirectUri);
 
         // generate the correlationId if not set by the user and add
         const correlationId = request.correlationId
             ? request.correlationId
             : this.config.cryptoInterface.createNewGuid();
-        ServerParamsGenerator.addCorrelationId(paramsMap, correlationId);
+        RequestUtils.addCorrelationId(paramsMap, correlationId);
 
         // add response_mode = fragment (currently hardcoded, have a future option to pass 'query' if the user chooses to)
-        ServerParamsGenerator.addResponseMode(paramsMap);
+        RequestUtils.addResponseMode(paramsMap, request.responseMode);
 
         // add response_type = code
-        ServerParamsGenerator.addResponseTypeCode(paramsMap);
+        RequestUtils.addResponseTypeCode(paramsMap);
 
         if (request.codeChallenge) {
             RequestValidator.validateCodeChallengeParams(request.codeChallenge, request.codeChallengeMethod);
-            ServerParamsGenerator.addCodeChallengeParams(paramsMap, request.codeChallenge, request.codeChallengeMethod);
+            RequestUtils.addCodeChallengeParams(paramsMap, request.codeChallenge, request.codeChallengeMethod);
         }
 
         if (request.state) {
-            ServerParamsGenerator.addState(paramsMap, request.state);
+            RequestUtils.addState(paramsMap, request.state);
         }
 
         if (request.prompt) {
             RequestValidator.validatePrompt(request.prompt);
-            ServerParamsGenerator.addPrompt(paramsMap, request.prompt);
+            RequestUtils.addPrompt(paramsMap, request.prompt);
         }
 
         if (request.loginHint) {
-            ServerParamsGenerator.addLoginHint(paramsMap, request.loginHint);
+            RequestUtils.addLoginHint(paramsMap, request.loginHint);
         }
 
         if (request.domainHint) {
-            ServerParamsGenerator.addDomainHint(paramsMap, request.domainHint);
+            RequestUtils.addDomainHint(paramsMap, request.domainHint);
         }
 
         if (request.nonce) {
-            ServerParamsGenerator.addNonce(paramsMap, request.nonce);
+            RequestUtils.addNonce(paramsMap, request.nonce);
+        }
+
+        if(request.claims) {
+            RequestUtils.addClaims(paramsMap, request.claims);
         }
 
         return paramsMap;

lib/msal-common/src/client/AuthorizationCodeClient.ts

@@ -13,7 +13,7 @@ import { Logger } from "../logger/Logger";
 import { AuthorityFactory } from "../authority/AuthorityFactory";
 import { Constants } from "../utils/Constants";
 import {ClientAuthError} from "../error/ClientAuthError";
-import {ServerParamsGenerator} from "../server/ServerParamsGenerator";
+import {RequestUtils} from "../utils/RequestUtils";
 
 /**
  * @hidden
@@ -108,8 +108,27 @@ export abstract class BaseClient {
      */
     protected createDefaultTokenRequestHeaders(): Map<string, string> {
         const headers = new Map<string, string>();
-        ServerParamsGenerator.addContentTypeHeader(headers);
-        ServerParamsGenerator.addLibrarydataHeaders(headers);
+        RequestUtils.addContentTypeHeader(headers);
+        RequestUtils.addLibrarydataHeaders(headers);
         return headers;
     }
+
+    /**
+     * Http post to token endpoint
+     * @param tokenEndpoint
+     * @param queryString
+     * @param headers
+     */
+    protected async executePostToTokenEndpoint(
+        tokenEndpoint: string,
+        queryString: string,
+        headers: Map<string, string> ): Promise<string> {
+
+        return this.networkClient.sendPostRequestAsync<string>(
+            tokenEndpoint,
+            {
+                body: queryString,
+                headers: headers,
+            });
+    }
 }