@microsoft/teamsfx 0.4.1 → 0.4.2-alpha.01a113d2.0

package/dist/index.esm2017.js

@@ -1,8 +1,7 @@
 import jwt_decode from 'jwt-decode';
 import * as microsoftTeams from '@microsoft/teams-js';
-import axios from 'axios';
+import { PublicClientApplication } from '@azure/msal-browser';
 import { Client } from '@microsoft/microsoft-graph-client';
-import { ManagedIdentityCredential } from '@azure/identity';
 
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
@@ -56,6 +55,10 @@ var ErrorCode;
      * Operation failed.
      */
     ErrorCode["FailedOperation"] = "FailedOperation";
+    /**
+     * Version of SDK and project does not match.
+     */
+    ErrorCode["ProjectNeedUpgrade"] = "ProjectNeedUpgrade";
 })(ErrorCode || (ErrorCode = {}));
 /**
  * @internal
@@ -168,7 +171,7 @@ function getLogLevel() {
     return internalLogger.level;
 }
 class InternalLogger {
-    constructor() {
+    constructor(name, logLevel) {
         this.level = undefined;
         this.defaultLogger = {
             verbose: console.debug,
@@ -176,6 +179,8 @@ class InternalLogger {
             warn: console.warn,
             error: console.error,
         };
+        this.name = name;
+        this.level = logLevel;
     }
     error(message) {
         this.log(LogLevel.Error, (x) => x.error, message);
@@ -194,7 +199,13 @@ class InternalLogger {
             return;
         }
         const timestamp = new Date().toUTCString();
-        const logHeader = `[${timestamp}] : @microsoft/teamsfx : ${LogLevel[logLevel]} - `;
+        let logHeader;
+        if (this.name) {
+            logHeader = `[${timestamp}] : @microsoft/teamsfx - ${this.name} : ${LogLevel[logLevel]} - `;
+        }
+        else {
+            logHeader = `[${timestamp}] : @microsoft/teamsfx : ${LogLevel[logLevel]} - `;
+        }
         const logMessage = `${logHeader}${message}`;
         if (this.level !== undefined && this.level <= logLevel) {
             if (this.customLogger) {
@@ -302,6 +313,57 @@ function getUserInfoFromSsoToken(ssoToken) {
     }
     return userInfo;
 }
+/**
+ * @internal
+ */
+function getTenantIdAndLoginHintFromSsoToken(ssoToken) {
+    if (!ssoToken) {
+        const errorMsg = "SSO token is undefined.";
+        internalLogger.error(errorMsg);
+        throw new ErrorWithCode(errorMsg, ErrorCode.InvalidParameter);
+    }
+    const tokenObject = parseJwt(ssoToken);
+    const userInfo = {
+        tid: tokenObject.tid,
+        loginHint: tokenObject.ver === "2.0"
+            ? tokenObject.preferred_username
+            : tokenObject.upn,
+    };
+    return userInfo;
+}
+/**
+ * @internal
+ */
+function parseAccessTokenFromAuthCodeTokenResponse(tokenResponse) {
+    try {
+        const tokenResponseObject = typeof tokenResponse == "string"
+            ? JSON.parse(tokenResponse)
+            : tokenResponse;
+        if (!tokenResponseObject || !tokenResponseObject.accessToken) {
+            const errorMsg = "Get empty access token from Auth Code token response.";
+            internalLogger.error(errorMsg);
+            throw new Error(errorMsg);
+        }
+        const token = tokenResponseObject.accessToken;
+        const tokenObject = parseJwt(token);
+        if (tokenObject.ver !== "1.0" && tokenObject.ver !== "2.0") {
+            const errorMsg = "SSO token is not valid with an unknown version: " + tokenObject.ver;
+            internalLogger.error(errorMsg);
+            throw new Error(errorMsg);
+        }
+        const accessToken = {
+            token: token,
+            expiresOnTimestamp: tokenObject.exp * 1000,
+        };
+        return accessToken;
+    }
+    catch (error) {
+        const errorMsg = "Parse access token failed from Auth Code token response in node env with error: " +
+            error.message;
+        internalLogger.error(errorMsg);
+        throw new ErrorWithCode(errorMsg, ErrorCode.InternalError);
+    }
+}
 /**
  * Format string template with replacements
  *
@@ -541,43 +603,10 @@ class OnBehalfOfUserCredential {
 }
 
 // Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-/**
- * Configuration used in initialization.
- * @internal
- */
-class Cache {
-    static get(key) {
-        return sessionStorage.getItem(key);
-    }
-    static set(key, value) {
-        sessionStorage.setItem(key, value);
-    }
-    static remove(key) {
-        sessionStorage.removeItem(key);
-    }
-}
-
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-/**
- * @internal
- */
-var GrantType;
-(function (GrantType) {
-    GrantType["authCode"] = "authorization_code";
-    GrantType["ssoToken"] = "sso_token";
-})(GrantType || (GrantType = {}));
-
-// Copyright (c) Microsoft Corporation.
-const accessTokenCacheKeyPrefix = "accessToken";
-const separator = "-";
 const tokenRefreshTimeSpanInMillisecond = 5 * 60 * 1000;
 const initializeTeamsSdkTimeoutInMillisecond = 5000;
 const loginPageWidth = 600;
 const loginPageHeight = 535;
-const maxRetryCount = 3;
-const retryTimeSpanInMillisecond = 3000;
 /**
  * Represent Teams current user's identity, and it is used within Teams tab application.
  *
@@ -595,7 +624,6 @@ class TeamsUserCredential {
      * ```typescript
      * const config = {
      *  authentication: {
-     *    runtimeConnectorEndpoint: "https://xxx.xxx.com",
      *    initiateLoginEndpoint: "https://localhost:3000/auth-start.html",
      *    clientId: "xxx"
      *   }
@@ -613,6 +641,7 @@ class TeamsUserCredential {
         internalLogger.info("Create teams user credential");
         this.config = this.loadAndValidateConfig();
         this.ssoToken = null;
+        this.initialized = false;
     }
     /**
      * Popup login page to get user's access token with specific scopes.
@@ -630,7 +659,6 @@ class TeamsUserCredential {
      * @param scopes - The list of scopes for which the token will have access, before that, we will request user to consent.
      *
      * @throws {@link ErrorCode|InternalError} when failed to login with unknown error.
-     * @throws {@link ErrorCode|ServiceError} when simple auth server failed to exchange access token.
      * @throws {@link ErrorCode|ConsentFailed} when user canceled or failed to consent.
      * @throws {@link ErrorCode|InvalidParameter} when scopes is not a valid string or string array.
      * @throws {@link ErrorCode|RuntimeNotSupported} when runtime is nodeJS.
@@ -641,27 +669,46 @@ class TeamsUserCredential {
         validateScopesType(scopes);
         const scopesStr = typeof scopes === "string" ? scopes : scopes.join(" ");
         internalLogger.info(`Popup login page to get user's access token with scopes: ${scopesStr}`);
+        if (!this.initialized) {
+            await this.init();
+        }
         return new Promise((resolve, reject) => {
             microsoftTeams.initialize(() => {
                 microsoftTeams.authentication.authenticate({
-                    url: `${this.config.initiateLoginEndpoint}?clientId=${this.config.clientId}&scope=${encodeURI(scopesStr)}`,
+                    url: `${this.config.initiateLoginEndpoint}?clientId=${this.config.clientId}&scope=${encodeURI(scopesStr)}&loginHint=${this.loginHint}`,
                     width: loginPageWidth,
                     height: loginPageHeight,
                     successCallback: async (result) => {
                         if (!result) {
-                            const errorMsg = "Get empty authentication result from Teams";
+                            const errorMsg = "Get empty authentication result from MSAL";
                             internalLogger.error(errorMsg);
                             reject(new ErrorWithCode(errorMsg, ErrorCode.InternalError));
                             return;
                         }
-                        const authCodeResult = JSON.parse(result);
+                        let resultJson = {};
                         try {
-                            await this.exchangeAccessTokenFromSimpleAuthServer(scopesStr, authCodeResult);
+                            resultJson = JSON.parse(result);
+                        }
+                        catch (error) {
+                            // If can not parse result as Json, will NOT throw error since user may return other info in auth-end page.
+                            // TODO: resolve the result.
+                            const failedToParseResult = "Failed to parse result to Json.";
+                            internalLogger.verbose(failedToParseResult);
                             resolve();
+                            return;
+                        }
+                        // If code exists in result, user may using previous auth-start and auth-end page.
+                        if (resultJson.code) {
+                            const helpLink = "https://aka.ms/teamsfx-auth-code-flow";
+                            const usingPreviousAuthPage = "Found auth code in response. You may be using the latest TeamsFx SDK on an old project." +
+                                `Please refer to the help link for how to fix the issue: ${helpLink}.`;
+                            reject(new ErrorWithCode(usingPreviousAuthPage, ErrorCode.ProjectNeedUpgrade));
                         }
-                        catch (err) {
-                            reject(this.generateAuthServerError(err));
+                        // If sessionStorage exists in result, set the values in current session storage.
+                        if (resultJson.sessionStorage) {
+                            this.setSessionStorage(resultJson.sessionStorage);
                         }
+                        resolve();
                     },
                     failureCallback: (reason) => {
                         const errorMsg = `Consent failed for the scope ${scopesStr} with error: ${reason}`;
@@ -696,7 +743,6 @@ class TeamsUserCredential {
      *
      * @throws {@link ErrorCode|InternalError} when failed to get access token with unknown error.
      * @throws {@link ErrorCode|UiRequiredError} when need user consent to get access token.
-     * @throws {@link ErrorCode|ServiceError} when failed to get access token from simple auth server.
      * @throws {@link ErrorCode|InvalidParameter} when scopes is not a valid string or string array.
      * @throws {@link ErrorCode|RuntimeNotSupported} when runtime is nodeJS.
      *
@@ -717,21 +763,47 @@ class TeamsUserCredential {
         }
         else {
             internalLogger.info("Get access token with scopes: " + scopeStr);
-            const cachedKey = await this.getAccessTokenCacheKey(scopeStr);
-            const cachedToken = this.getTokenCache(cachedKey);
-            if (cachedToken) {
-                if (!this.isAccessTokenNearExpired(cachedToken)) {
-                    internalLogger.verbose("Get access token from cache");
-                    return cachedToken;
+            if (!this.initialized) {
+                await this.init();
+            }
+            let tokenResponse;
+            const scopesArray = typeof scopes === "string" ? scopes.split(" ") : scopes;
+            const domain = window.location.origin;
+            // First try to get Access Token from cache.
+            try {
+                const account = this.msalInstance.getAccountByUsername(this.loginHint);
+                const scopesRequestForAcquireTokenSilent = {
+                    scopes: scopesArray,
+                    account: account !== null && account !== void 0 ? account : undefined,
+                    redirectUri: `${domain}/blank-auth-end.html`,
+                };
+                tokenResponse = await this.msalInstance.acquireTokenSilent(scopesRequestForAcquireTokenSilent);
+            }
+            catch (error) {
+                const acquireTokenSilentFailedMessage = `Failed to call acquireTokenSilent. Reason: ${error === null || error === void 0 ? void 0 : error.message}. `;
+                internalLogger.verbose(acquireTokenSilentFailedMessage);
+            }
+            if (!tokenResponse) {
+                // If fail to get Access Token from cache, try to get Access token by silent login.
+                try {
+                    const scopesRequestForSsoSilent = {
+                        scopes: scopesArray,
+                        loginHint: this.loginHint,
+                        redirectUri: `${domain}/blank-auth-end.html`,
+                    };
+                    tokenResponse = await this.msalInstance.ssoSilent(scopesRequestForSsoSilent);
                 }
-                else {
-                    internalLogger.verbose("Cached access token is expired");
+                catch (error) {
+                    const ssoSilentFailedMessage = `Failed to call ssoSilent. Reason: ${error === null || error === void 0 ? void 0 : error.message}. `;
+                    internalLogger.verbose(ssoSilentFailedMessage);
                 }
             }
-            else {
-                internalLogger.verbose("No cached access token");
+            if (!tokenResponse) {
+                const errorMsg = `Failed to get access token cache silently, please login first: you need login first before get access token.`;
+                internalLogger.error(errorMsg);
+                throw new ErrorWithCode(errorMsg, ErrorCode.UiRequiredError);
             }
-            const accessToken = await this.getAndCacheAccessTokenFromSimpleAuthServer(scopeStr);
+            const accessToken = parseAccessTokenFromAuthCodeTokenResponse(tokenResponse);
             return accessToken;
         }
     }
@@ -756,65 +828,22 @@ class TeamsUserCredential {
         const ssoToken = await this.getSSOToken();
         return getUserInfoFromSsoToken(ssoToken.token);
     }
-    async exchangeAccessTokenFromSimpleAuthServer(scopesStr, authCodeResult) {
-        var _a, _b;
-        const axiosInstance = await this.getAxiosInstance();
-        let retryCount = 0;
-        while (true) {
-            try {
-                const response = await axiosInstance.post("/auth/token", {
-                    scope: scopesStr,
-                    code: authCodeResult.code,
-                    code_verifier: authCodeResult.codeVerifier,
-                    redirect_uri: authCodeResult.redirectUri,
-                    grant_type: GrantType.authCode,
-                });
-                const tokenResult = response.data;
-                const key = await this.getAccessTokenCacheKey(scopesStr);
-                // Important: tokens are stored in sessionStorage, read more here: https://aka.ms/teamsfx-session-storage-notice
-                this.setTokenCache(key, {
-                    token: tokenResult.access_token,
-                    expiresOnTimestamp: tokenResult.expires_on,
-                });
-                return;
-            }
-            catch (err) {
-                if (((_b = (_a = err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.type) && err.response.data.type === "AadUiRequiredException") {
-                    internalLogger.warn("Exchange access token failed, retry...");
-                    if (retryCount < maxRetryCount) {
-                        await this.sleep(retryTimeSpanInMillisecond);
-                        retryCount++;
-                        continue;
-                    }
-                }
-                throw err;
-            }
-        }
-    }
-    /**
-     * Get access token cache from authentication server
-     * @returns Access token
-     */
-    async getAndCacheAccessTokenFromSimpleAuthServer(scopesStr) {
-        try {
-            internalLogger.verbose("Get access token from authentication server with scopes: " + scopesStr);
-            const axiosInstance = await this.getAxiosInstance();
-            const response = await axiosInstance.post("/auth/token", {
-                scope: scopesStr,
-                grant_type: GrantType.ssoToken,
-            });
-            const accessTokenResult = response.data;
-            const accessToken = {
-                token: accessTokenResult.access_token,
-                expiresOnTimestamp: accessTokenResult.expires_on,
-            };
-            const cacheKey = await this.getAccessTokenCacheKey(scopesStr);
-            this.setTokenCache(cacheKey, accessToken);
-            return accessToken;
-        }
-        catch (err) {
-            throw this.generateAuthServerError(err);
-        }
+    async init() {
+        const ssoToken = await this.getSSOToken();
+        const info = getTenantIdAndLoginHintFromSsoToken(ssoToken.token);
+        this.loginHint = info.loginHint;
+        this.tid = info.tid;
+        const msalConfig = {
+            auth: {
+                clientId: this.config.clientId,
+                authority: `https://login.microsoftonline.com/${this.tid}`,
+            },
+            cache: {
+                cacheLocation: "sessionStorage",
+            },
+        };
+        this.msalInstance = new PublicClientApplication(msalConfig);
+        this.initialized = true;
     }
     /**
      * Get SSO token using teams SDK
@@ -884,16 +913,13 @@ class TeamsUserCredential {
             internalLogger.error(ErrorMessage.AuthenticationConfigurationNotExists);
             throw new ErrorWithCode(ErrorMessage.AuthenticationConfigurationNotExists, ErrorCode.InvalidConfiguration);
         }
-        if (config.initiateLoginEndpoint && config.simpleAuthEndpoint && config.clientId) {
+        if (config.initiateLoginEndpoint && config.clientId) {
             return config;
         }
         const missingValues = [];
         if (!config.initiateLoginEndpoint) {
             missingValues.push("initiateLoginEndpoint");
         }
-        if (!config.simpleAuthEndpoint) {
-            missingValues.push("simpleAuthEndpoint");
-        }
         if (!config.clientId) {
             missingValues.push("clientId");
         }
@@ -901,111 +927,20 @@ class TeamsUserCredential {
         internalLogger.error(errorMsg);
         throw new ErrorWithCode(errorMsg, ErrorCode.InvalidConfiguration);
     }
-    /**
-     * Get axios instance with sso token bearer header
-     * @returns AxiosInstance
-     */
-    async getAxiosInstance() {
-        const ssoToken = await this.getSSOToken();
-        const axiosInstance = axios.create({
-            baseURL: this.config.simpleAuthEndpoint,
-        });
-        axiosInstance.interceptors.request.use((config) => {
-            config.headers.Authorization = "Bearer " + ssoToken.token;
-            return config;
-        });
-        return axiosInstance;
-    }
-    /**
-     * Set access token to cache
-     * @param key
-     * @param token
-     */
-    setTokenCache(key, token) {
-        Cache.set(key, JSON.stringify(token));
-    }
-    /**
-     * Get access token from cache.
-     * If there is no cache or cannot be parsed, then it will return null
-     * @param key
-     * @returns Access token or null
-     */
-    getTokenCache(key) {
-        const value = Cache.get(key);
-        if (value === null) {
-            return null;
-        }
-        const accessToken = this.validateAndParseJson(value);
-        return accessToken;
-    }
-    /**
-     * Parses passed value as JSON access token, if value is not a valid json string JSON.parse() will throw an error.
-     * @param jsonValue
-     */
-    validateAndParseJson(jsonValue) {
+    setSessionStorage(sessonStorageValues) {
         try {
-            const parsedJson = JSON.parse(jsonValue);
-            /**
-             * There are edge cases in which JSON.parse will successfully parse a non-valid JSON object
-             * (e.g. JSON.parse will parse an escaped string into an unescaped string), so adding a type check
-             * of the parsed value is necessary in order to be certain that the string represents a valid JSON object.
-             *
-             */
-            return parsedJson && typeof parsedJson === "object" ? parsedJson : null;
+            const sessionStorageKeys = Object.keys(sessonStorageValues);
+            sessionStorageKeys.forEach((key) => {
+                sessionStorage.setItem(key, sessonStorageValues[key]);
+            });
         }
         catch (error) {
-            return null;
-        }
-    }
-    /**
-     * Generate cache key
-     * @param scopesStr
-     * @returns Access token cache key, a key example: accessToken-userId-clientId-tenantId-scopes
-     */
-    async getAccessTokenCacheKey(scopesStr) {
-        const ssoToken = await this.getSSOToken();
-        const ssoTokenObj = parseJwt(ssoToken.token);
-        const clientId = this.config.clientId;
-        const userObjectId = ssoTokenObj.oid;
-        const tenantId = ssoTokenObj.tid;
-        const key = [accessTokenCacheKeyPrefix, userObjectId, clientId, tenantId, scopesStr]
-            .join(separator)
-            .replace(/" "/g, "_");
-        return key;
-    }
-    /**
-     * Check whether the token is about to expire (within 5 minutes)
-     * @returns Boolean value indicate whether the token is about to expire
-     */
-    isAccessTokenNearExpired(token) {
-        const expireDate = new Date(token.expiresOnTimestamp);
-        if (expireDate.getTime() - Date.now() > tokenRefreshTimeSpanInMillisecond) {
-            return false;
+            // Values in result.sessionStorage can not be set into session storage.
+            // Throw error since this may block user.
+            const errorMessage = `Failed to set values in session storage. Error: ${error.message}`;
+            internalLogger.error(errorMessage);
+            throw new ErrorWithCode(errorMessage, ErrorCode.InternalError);
         }
-        return true;
-    }
-    generateAuthServerError(err) {
-        var _a, _b;
-        let errorMessage = err.message;
-        if ((_b = (_a = err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.type) {
-            errorMessage = err.response.data.detail;
-            if (err.response.data.type === "AadUiRequiredException") {
-                const fullErrorMsg = "Failed to get access token from authentication server, please login first: " +
-                    errorMessage;
-                internalLogger.warn(fullErrorMsg);
-                return new ErrorWithCode(fullErrorMsg, ErrorCode.UiRequiredError);
-            }
-            else {
-                const fullErrorMsg = "Failed to get access token from authentication server: " + errorMessage;
-                internalLogger.error(fullErrorMsg);
-                return new ErrorWithCode(fullErrorMsg, ErrorCode.ServiceError);
-            }
-        }
-        const fullErrorMsg = "Failed to get access token with error: " + errorMessage;
-        return new ErrorWithCode(fullErrorMsg, ErrorCode.InternalError);
-    }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
     }
 }
 
@@ -1133,174 +1068,25 @@ function createMicrosoftGraphClient(credential, scopes) {
 
 // Copyright (c) Microsoft Corporation.
 /**
- * SQL connection configuration instance.
+ * Generate connection configuration consumed by tedious.
  * @remarks
  * Only works in in server side.
- *
  * @beta
- *
  */
 class DefaultTediousConnectionConfiguration {
     constructor() {
-        /**
-         * MSSQL default scope
-         * https://docs.microsoft.com/en-us/azure/app-service/app-service-web-tutorial-connect-msi
-         */
-        this.defaultSQLScope = "https://database.windows.net/";
+        throw new ErrorWithCode(formatString(ErrorMessage.BrowserRuntimeNotSupported, "DefaultTediousConnectionConfiguration"), ErrorCode.RuntimeNotSupported);
     }
     /**
      * Generate connection configuration consumed by tedious.
-     *
-     * @returns Connection configuration of tedious for the SQL.
-     *
-     * @throws {@link ErrorCode|InvalidConfiguration} when SQL config resource configuration is invalid.
-     * @throws {@link ErrorCode|InternalError} when get user MSI token failed or MSI token is invalid.
-     * @throws {@link ErrorCode|RuntimeNotSupported} when runtime is browser.
-     *
+     * @remarks
+     * Only works in in server side.
      * @beta
      */
-    async getConfig() {
-        internalLogger.info("Get SQL configuration");
-        const configuration = getResourceConfiguration(ResourceType.SQL);
-        if (!configuration) {
-            const errMsg = "SQL resource configuration not exist";
-            internalLogger.error(errMsg);
-            throw new ErrorWithCode(errMsg, ErrorCode.InvalidConfiguration);
-        }
-        try {
-            this.isSQLConfigurationValid(configuration);
-        }
-        catch (err) {
-            throw err;
-        }
-        if (!this.isMsiAuthentication()) {
-            const configWithUPS = this.generateDefaultConfig(configuration);
-            internalLogger.verbose("SQL configuration with username and password generated");
-            return configWithUPS;
-        }
-        try {
-            const configWithToken = await this.generateTokenConfig(configuration);
-            internalLogger.verbose("SQL configuration with MSI token generated");
-            return configWithToken;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    /**
-     * Check SQL use MSI identity or username and password.
-     *
-     * @returns false - login with SQL MSI identity, true - login with username and password.
-     * @internal
-     */
-    isMsiAuthentication() {
-        internalLogger.verbose("Check connection config using MSI access token or username and password");
-        const configuration = getResourceConfiguration(ResourceType.SQL);
-        if ((configuration === null || configuration === void 0 ? void 0 : configuration.sqlUsername) != null && (configuration === null || configuration === void 0 ? void 0 : configuration.sqlPassword) != null) {
-            internalLogger.verbose("Login with username and password");
-            return false;
-        }
-        internalLogger.verbose("Login with MSI identity");
-        return true;
-    }
-    /**
-     * check configuration is an available configurations.
-     * @param { SqlConfiguration } sqlConfig
-     *
-     * @returns true - SQL configuration has a valid SQL endpoints, SQL username with password or identity ID.
-     *          false - configuration is not valid.
-     * @internal
-     */
-    isSQLConfigurationValid(sqlConfig) {
-        internalLogger.verbose("Check SQL configuration if valid");
-        if (!sqlConfig.sqlServerEndpoint) {
-            internalLogger.error("SQL configuration is not valid without SQL server endpoint exist");
-            throw new ErrorWithCode("SQL configuration error without SQL server endpoint exist", ErrorCode.InvalidConfiguration);
-        }
-        if (!(sqlConfig.sqlUsername && sqlConfig.sqlPassword) && !sqlConfig.sqlIdentityId) {
-            const errMsg = `SQL configuration is not valid without ${sqlConfig.sqlIdentityId ? "" : "identity id "} ${sqlConfig.sqlUsername ? "" : "SQL username "} ${sqlConfig.sqlPassword ? "" : "SQL password"} exist`;
-            internalLogger.error(errMsg);
-            throw new ErrorWithCode(errMsg, ErrorCode.InvalidConfiguration);
-        }
-        internalLogger.verbose("SQL configuration is valid");
-    }
-    /**
-     * Generate tedious connection configuration with default authentication type.
-     *
-     * @param { SqlConfiguration } SQL configuration with username and password.
-     *
-     * @returns Tedious connection configuration with username and password.
-     * @internal
-     */
-    generateDefaultConfig(sqlConfig) {
-        internalLogger.verbose(`SQL server ${sqlConfig.sqlServerEndpoint}, user name ${sqlConfig.sqlUsername}, database name ${sqlConfig.sqlDatabaseName}`);
-        const config = {
-            server: sqlConfig.sqlServerEndpoint,
-            authentication: {
-                type: TediousAuthenticationType.default,
-                options: {
-                    userName: sqlConfig.sqlUsername,
-                    password: sqlConfig.sqlPassword,
-                },
-            },
-            options: {
-                database: sqlConfig.sqlDatabaseName,
-                encrypt: true,
-            },
-        };
-        return config;
-    }
-    /**
-     * Generate tedious connection configuration with azure-active-directory-access-token authentication type.
-     *
-     * @param { SqlConfiguration } SQL configuration with AAD access token.
-     *
-     * @returns Tedious connection configuration with access token.
-     * @internal
-     */
-    async generateTokenConfig(sqlConfig) {
-        internalLogger.verbose("Generate tedious config with MSI token");
-        let token;
-        try {
-            const credential = new ManagedIdentityCredential(sqlConfig.sqlIdentityId);
-            token = await credential.getToken(this.defaultSQLScope);
-        }
-        catch (error) {
-            const errMsg = "Get user MSI token failed";
-            internalLogger.error(errMsg);
-            throw new ErrorWithCode(errMsg, ErrorCode.InternalError);
-        }
-        if (token) {
-            const config = {
-                server: sqlConfig.sqlServerEndpoint,
-                authentication: {
-                    type: TediousAuthenticationType.MSI,
-                    options: {
-                        token: token.token,
-                    },
-                },
-                options: {
-                    database: sqlConfig.sqlDatabaseName,
-                    encrypt: true,
-                },
-            };
-            internalLogger.verbose(`Generate token configuration success, server endpoint is ${sqlConfig.sqlServerEndpoint}, database name is ${sqlConfig.sqlDatabaseName}`);
-            return config;
-        }
-        internalLogger.error(`Generate token configuration, server endpoint is ${sqlConfig.sqlServerEndpoint}, MSI token is not valid`);
-        throw new ErrorWithCode("MSI token is not valid", ErrorCode.InternalError);
+    async getConfig(databaseName) {
+        throw new ErrorWithCode(formatString(ErrorMessage.BrowserRuntimeNotSupported, "DefaultTediousConnectionConfiguration"), ErrorCode.RuntimeNotSupported);
     }
-}
-/**
- * tedious connection config authentication type.
- * https://tediousjs.github.io/tedious/api-connection.html
- * @internal
- */
-var TediousAuthenticationType;
-(function (TediousAuthenticationType) {
-    TediousAuthenticationType["default"] = "default";
-    TediousAuthenticationType["MSI"] = "azure-active-directory-access-token";
-})(TediousAuthenticationType || (TediousAuthenticationType = {}));
+}
 
 // Copyright (c) Microsoft Corporation.
 /**