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, PerformanceEvents, AuthError } from '@azure/msal-common/browser';
import { StandardInteractionClient, initializeAuthorizationRequest } from './StandardInteractionClient.mjs';
import { StandardInteractionClientInitializeAuthorizationRequest, StandardInteractionClientGetClientConfiguration } from '../telemetry/BrowserPerformanceEvents.mjs';
import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
import { InteractionType } from '../utils/BrowserConstants.mjs';
import { HybridSpaAuthorizationCodeClient } from './HybridSpaAuthorizationCodeClient.mjs';
import { InteractionHandler } from '../interaction_handler/InteractionHandler.mjs';
import { initializeServerTelemetryManager } from './BaseInteractionClient.mjs';
import { authCodeRequired, silentLogoutUnsupported } from '../error/BrowserAuthErrorCodes.mjs';
 
/* 
 * Copyright (c) Microsoft Corporation. All rights reserved. 
 * Licensed under the MIT License. 
 */ 
class SilentAuthCodeClient extends StandardInteractionClient { 
    constructor(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, apiId, performanceClient, correlationId, platformAuthProvider) { 
        super(config, storageImpl, browserCrypto, logger, eventHandler, navigationClient, performanceClient, correlationId, platformAuthProvider); 
        this.apiId = apiId; 
    } 
    /** 
     * Acquires a token silently by redeeming an authorization code against the /token endpoint 
     * @param request 
     */ 
    async acquireToken(request) { 
        // Auth code payload is required 
        if (!request.code) { 
            throw createBrowserAuthError(authCodeRequired); 
        } 
        // Create silent request 
        const silentRequest = await invokeAsync(initializeAuthorizationRequest, StandardInteractionClientInitializeAuthorizationRequest, this.logger, this.performanceClient, this.correlationId)(request, InteractionType.Silent, this.config, this.browserCrypto, this.browserStorage, this.logger, this.performanceClient,  
        /* 
         * correlationId is optional in request payload, while this.correlationId is always instantiated as request.correlationId || createGuid(). 
         * Each auth request creates a new instance of *Client so we can safely use this.correlationId. 
         */ 
        this.correlationId); 
        const serverTelemetryManager = initializeServerTelemetryManager(this.apiId, this.config.auth.clientId, this.correlationId, this.browserStorage, this.logger); 
        try { 
            // Create auth code request (PKCE not needed) 
            const authCodeRequest = { 
                ...silentRequest, 
                code: request.code, 
            }; 
            // Initialize the client 
            const clientConfig = await invokeAsync(this.getClientConfiguration.bind(this), StandardInteractionClientGetClientConfiguration, this.logger, this.performanceClient, this.correlationId)({ 
                serverTelemetryManager, 
                requestAuthority: silentRequest.authority, 
                requestAzureCloudOptions: silentRequest.azureCloudOptions, 
                requestExtraQueryParameters: silentRequest.extraQueryParameters, 
                account: silentRequest.account, 
            }); 
            const authClient = new HybridSpaAuthorizationCodeClient(clientConfig, this.performanceClient); 
            this.logger.verbose("1uic5e", this.correlationId); 
            // Create silent handler 
            const interactionHandler = new InteractionHandler(authClient, this.browserStorage, authCodeRequest, this.logger, this.performanceClient); 
            // Handle auth code parameters from request 
            return await invokeAsync(interactionHandler.handleCodeResponseFromServer.bind(interactionHandler), PerformanceEvents.HandleCodeResponseFromServer, this.logger, this.performanceClient, this.correlationId)({ 
                code: request.code, 
                msgraph_host: request.msGraphHost, 
                cloud_graph_host_name: request.cloudGraphHostName, 
                cloud_instance_host_name: request.cloudInstanceHostName, 
            }, silentRequest, this.apiId, false); 
        } 
        catch (e) { 
            if (e instanceof AuthError) { 
                e.setCorrelationId(this.correlationId); 
                serverTelemetryManager.cacheFailedRequest(e); 
            } 
            throw e; 
        } 
    } 
    /** 
     * Currently Unsupported 
     */ 
    logout() { 
        // Synchronous so we must reject 
        return Promise.reject(createBrowserAuthError(silentLogoutUnsupported)); 
    } 
}
 
export { SilentAuthCodeClient };
//# sourceMappingURL=SilentAuthCodeClient.mjs.map