first commit

wangzhibo

2026-05-09 53418655c061ac26f66058253f39200aced1ab1d

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
/*! @azure/msal-browser v5.7.0 2026-04-16 */
'use strict';
import { invokeAsync, ProtocolMode, Constants, createClientConfigurationError, ClientConfigurationErrorCodes } from '@azure/msal-common/browser';
import { InitializeBaseRequest } from '../telemetry/BrowserPerformanceEvents.mjs';
 
/* 
 * Copyright (c) Microsoft Corporation. All rights reserved. 
 * Licensed under the MIT License. 
 */ 
/** 
 * Initializer function for all request APIs 
 * @param request 
 * @param config 
 * @param performanceClient 
 * @param logger 
 * @param correlationId 
 */ 
async function initializeBaseRequest(request, config, performanceClient, logger, correlationId) { 
    const authority = request.authority || config.auth.authority; 
    const scopes = [...((request && request.scopes) || [])]; 
    const validatedRequest = { 
        ...request, 
        correlationId: request.correlationId, 
        authority, 
        scopes, 
    }; 
    // Set authenticationScheme to BEARER if not explicitly set in the request 
    if (!validatedRequest.authenticationScheme) { 
        validatedRequest.authenticationScheme = 
            Constants.AuthenticationScheme.BEARER; 
        logger.verbose("1l4fwv", correlationId); 
    } 
    else { 
        if (validatedRequest.authenticationScheme === 
            Constants.AuthenticationScheme.SSH) { 
            if (!request.sshJwk) { 
                throw createClientConfigurationError(ClientConfigurationErrorCodes.missingSshJwk); 
            } 
            if (!request.sshKid) { 
                throw createClientConfigurationError(ClientConfigurationErrorCodes.missingSshKid); 
            } 
        } 
        logger.verbose("1ecmns", correlationId); 
    } 
    return validatedRequest; 
} 
async function initializeSilentRequest(request, account, config, performanceClient, logger) { 
    const baseRequest = await invokeAsync(initializeBaseRequest, InitializeBaseRequest, logger, performanceClient, request.correlationId)(request, config, performanceClient, logger, request.correlationId); 
    return { 
        ...request, 
        ...baseRequest, 
        account: account, 
        forceRefresh: request.forceRefresh || false, 
    }; 
} 
/** 
 * Validates that the combination of request method, protocol mode and authorize body parameters is correct. 
 * Returns the validated or defaulted HTTP method or throws if the configured combination is invalid. 
 * @param interactionRequest 
 * @param protocolMode 
 * @returns 
 */ 
function validateRequestMethod(interactionRequest, protocolMode) { 
    let httpMethod; 
    const requestMethod = interactionRequest.httpMethod; 
    if (protocolMode === ProtocolMode.EAR) { 
        // Validate that method can only be POST when protocol mode is EAR 
        if (requestMethod && requestMethod !== Constants.HttpMethod.POST) { 
            throw createClientConfigurationError(ClientConfigurationErrorCodes.invalidRequestMethodForEAR); 
        } 
        else { 
            httpMethod = Constants.HttpMethod.POST; 
        } 
    } 
    else { 
        // For non-EAR protocol modes, default to GET if httpMethod is not set 
        httpMethod = requestMethod || Constants.HttpMethod.GET; 
    } 
    return httpMethod; 
}
 
export { initializeBaseRequest, initializeSilentRequest, validateRequestMethod };
//# sourceMappingURL=RequestHelpers.mjs.map