azure-kusto-data 4.0.3 → 5.0.0

package/README.md

@@ -1,4 +1,4 @@
-# Microsoft Azure Kusto Data Library for Node
+# Microsoft Azure Kusto Data Library for JavaScript
 
 ## Installation
 
@@ -41,7 +41,6 @@ const kcsb = KustoConnectionStringBuilder.withAadApplicationCertificateAuthentic
     `https://${clusterName}.kusto.windows.net`,
     "appid",
     "certificate",
-    "thumbprint",
     "authorityId"
 );
 ```

package/dist-esm/src/client.js

@@ -0,0 +1,227 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KustoClient = void 0;
+const uuid_1 = require("uuid");
+const security_1 = __importDefault(require("./security"));
+const response_1 = require("./response");
+const connectionBuilder_1 = __importDefault(require("./connectionBuilder"));
+const clientRequestProperties_1 = __importDefault(require("./clientRequestProperties"));
+const errors_1 = require("./errors");
+const version_1 = require("./version");
+const axios_1 = __importDefault(require("axios"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const core_util_1 = require("@azure/core-util");
+const kustoTrustedEndpoints_1 = require("./kustoTrustedEndpoints");
+const cloudSettings_1 = require("./cloudSettings");
+const timeUtils_1 = require("./timeUtils");
+const COMMAND_TIMEOUT_IN_MILLISECS = (0, timeUtils_1.toMilliseconds)(0, 10, 30);
+const QUERY_TIMEOUT_IN_MILLISECS = (0, timeUtils_1.toMilliseconds)(0, 4, 30);
+const CLIENT_SERVER_DELTA_IN_MILLISECS = (0, timeUtils_1.toMilliseconds)(0, 0, 30);
+const MGMT_PREFIX = ".";
+var ExecutionType;
+(function (ExecutionType) {
+    ExecutionType["Mgmt"] = "mgmt";
+    ExecutionType["Query"] = "query";
+    ExecutionType["Ingest"] = "ingest";
+    ExecutionType["QueryV1"] = "queryv1";
+})(ExecutionType || (ExecutionType = {}));
+class KustoClient {
+    constructor(kcsb) {
+        this.cancelToken = axios_1.default.CancelToken.source();
+        this._isClosed = false;
+        this.connectionString = typeof kcsb === "string" ? new connectionBuilder_1.default(kcsb) : kcsb;
+        if (!this.connectionString.dataSource) {
+            throw new Error("Cluster url is required");
+        }
+        const url = new URL(this.connectionString.dataSource);
+        this.cluster = `${url.protocol}//${url.hostname}${url.port ? `:${url.port}` : ""}`;
+        this.defaultDatabase = this.connectionString.initialCatalog;
+        this.endpoints = {
+            [ExecutionType.Mgmt]: `${this.cluster}/v1/rest/mgmt`,
+            [ExecutionType.Query]: `${this.cluster}/v2/rest/query`,
+            [ExecutionType.Ingest]: `${this.cluster}/v1/rest/ingest`,
+            [ExecutionType.QueryV1]: `${this.cluster}/v1/rest/query`,
+        };
+        this.aadHelper = new security_1.default(this.connectionString);
+        const headers = {
+            Accept: "application/json",
+            "Accept-Encoding": "gzip,deflate",
+            "x-ms-client-version": `Kusto.Node.Client:${version_1.SDK_VERSION}`,
+            Connection: "Keep-Alive",
+        };
+        const axiosProps = {
+            headers,
+            validateStatus: (status) => status === 200,
+        };
+        // http and https are Node modules and are not found in browsers
+        if (core_util_1.isNode) {
+            // keepAlive pools and reuses TCP connections, so it's faster
+            axiosProps.httpAgent = new http_1.default.Agent({ keepAlive: true });
+            axiosProps.httpsAgent = new https_1.default.Agent({ keepAlive: true });
+        }
+        axiosProps.cancelToken = this.cancelToken.token;
+        this.axiosInstance = axios_1.default.create();
+    }
+    async execute(db, query, properties) {
+        query = query.trim();
+        if (query.startsWith(MGMT_PREFIX)) {
+            return this.executeMgmt(db, query, properties);
+        }
+        return this.executeQuery(db, query, properties);
+    }
+    async executeQuery(db, query, properties) {
+        return this._execute(this.endpoints[ExecutionType.Query], ExecutionType.Query, db, query, null, properties);
+    }
+    async executeQueryV1(db, query, properties) {
+        return this._execute(this.endpoints[ExecutionType.QueryV1], ExecutionType.QueryV1, db, query, null, properties);
+    }
+    async executeMgmt(db, query, properties) {
+        return this._execute(this.endpoints[ExecutionType.Mgmt], ExecutionType.Mgmt, db, query, null, properties);
+    }
+    async executeStreamingIngest(db, table, stream, streamFormat, mappingName, clientRequestId) {
+        let endpoint = `${this.endpoints[ExecutionType.Ingest]}/${this.getDb(db)}/${table}?streamFormat=${streamFormat}`;
+        if (mappingName != null) {
+            endpoint += `&mappingName=${mappingName}`;
+        }
+        let properties = null;
+        if (clientRequestId) {
+            properties = new clientRequestProperties_1.default();
+            properties.clientRequestId = clientRequestId;
+        }
+        return this._execute(endpoint, ExecutionType.Ingest, db, null, stream, properties);
+    }
+    async _execute(endpoint, executionType, db, query, stream, properties) {
+        this.ensureOpen();
+        kustoTrustedEndpoints_1.kustoTrustedEndpoints.validateTrustedEndpoint(endpoint, (await cloudSettings_1.CloudSettings.getInstance().getCloudInfoForCluster(this.cluster)).LoginEndpoint);
+        db = this.getDb(db);
+        const headers = {};
+        let payload;
+        let clientRequestPrefix = "";
+        const timeout = this._getClientTimeout(executionType, properties);
+        let payloadContent = "";
+        if (query != null) {
+            payload = {
+                db,
+                csl: query,
+            };
+            if (properties != null) {
+                payload.properties = properties.toJSON();
+            }
+            payloadContent = JSON.stringify(payload);
+            headers["Content-Type"] = "application/json; charset=utf-8";
+            clientRequestPrefix = "KNC.execute;";
+        }
+        else if (stream != null) {
+            payloadContent = stream;
+            clientRequestPrefix = "KNC.executeStreamingIngest;";
+            if (core_util_1.isNode) {
+                headers["Content-Encoding"] = "gzip";
+                headers["Content-Type"] = "application/octet-stream";
+            }
+            else {
+                headers["Content-Type"] = "application/json";
+            }
+        }
+        else {
+            throw new Error("Invalid parameters - expected query or streaming ingest");
+        }
+        let kustoHeaders = this.connectionString.clientDetails().getHeaders();
+        kustoHeaders["x-ms-client-request-id"] = `${clientRequestPrefix}${(0, uuid_1.v4)()}`;
+        if (properties != null) {
+            kustoHeaders = Object.assign(Object.assign({}, kustoHeaders), properties.getHeaders());
+        }
+        for (const key of Object.keys(kustoHeaders)) {
+            if (kustoHeaders[key]) {
+                headers[key] = kustoHeaders[key];
+            }
+        }
+        const authHeader = await this.aadHelper.getAuthHeader();
+        if (authHeader != null) {
+            headers.Authorization = authHeader;
+        }
+        return this._doRequest(endpoint, executionType, headers, payloadContent, timeout, properties);
+    }
+    getDb(db) {
+        if (db == null) {
+            if (this.defaultDatabase == null) {
+                throw new Error("No database provided, and no default database specified in connection string");
+            }
+            db = this.defaultDatabase;
+        }
+        return db;
+    }
+    async _doRequest(endpoint, executionType, headers, payload, timeout, properties) {
+        const axiosConfig = {
+            headers,
+            timeout,
+        };
+        let axiosResponse;
+        try {
+            axiosResponse = await this.axiosInstance.post(endpoint, payload, axiosConfig);
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error) && error.response) {
+                if (error.response.status === 429) {
+                    throw new errors_1.ThrottlingError("POST request failed with status 429 (Too Many Requests)", error);
+                }
+            }
+            throw error;
+        }
+        return this._parseResponse(axiosResponse.data, executionType, properties, axiosResponse.status);
+    }
+    _parseResponse(response, executionType, properties, status) {
+        const { raw } = properties || {};
+        if (raw === true || executionType === ExecutionType.Ingest) {
+            return response;
+        }
+        let kustoResponse = null;
+        try {
+            if (executionType === ExecutionType.Query) {
+                kustoResponse = new response_1.KustoResponseDataSetV2(response);
+            }
+            else {
+                kustoResponse = new response_1.KustoResponseDataSetV1(response);
+            }
+        }
+        catch (ex) {
+            throw new Error(`Failed to parse response ({${status}}) with the following error [${ex}].`);
+        }
+        if (kustoResponse.getErrorsCount().errors > 0) {
+            throw new Error(`Kusto request had errors. ${kustoResponse.getExceptions()}`);
+        }
+        return kustoResponse;
+    }
+    _getClientTimeout(executionType, properties) {
+        if (properties != null) {
+            const clientTimeout = properties.getClientTimeout();
+            if (clientTimeout) {
+                return clientTimeout;
+            }
+            const serverTimeout = properties.getTimeout();
+            if (serverTimeout) {
+                return serverTimeout + CLIENT_SERVER_DELTA_IN_MILLISECS;
+            }
+        }
+        return executionType === ExecutionType.Query || executionType === ExecutionType.QueryV1 ? QUERY_TIMEOUT_IN_MILLISECS : COMMAND_TIMEOUT_IN_MILLISECS;
+    }
+    close() {
+        if (!this._isClosed) {
+            this.cancelToken.cancel("Client Closed");
+        }
+        this._isClosed = true;
+    }
+    ensureOpen() {
+        if (this._isClosed) {
+            throw new Error("Client is closed");
+        }
+    }
+}
+exports.KustoClient = KustoClient;
+exports.default = KustoClient;
+//# sourceMappingURL=client.js.map

package/dist-esm/src/clientDetails.js

@@ -0,0 +1,79 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDetails = void 0;
+const core_util_1 = require("@azure/core-util");
+const os_1 = require("os");
+const version_1 = require("./version");
+// REPLACE_REGEX = re.compile(r"[\r\n\s{}|]+")
+const ReplaceRegex = /[\r\n\s{}|]+/g;
+const None = "[none]";
+class ClientDetails {
+    constructor(applicationNameForTracing, userNameForTracing) {
+        this.applicationNameForTracing = applicationNameForTracing;
+        this.userNameForTracing = userNameForTracing;
+        if (this.applicationNameForTracing === null) {
+            this.applicationNameForTracing = ClientDetails.defaultApplication();
+        }
+        if (this.userNameForTracing === null) {
+            this.userNameForTracing = ClientDetails.defaultUser();
+        }
+        this.versionForTracing = ClientDetails.defaultVersion();
+    }
+    static defaultApplication() {
+        var _a, _b;
+        if (core_util_1.isNode) {
+            return ((_a = process.env) === null || _a === void 0 ? void 0 : _a.npm_package_name) || process.title || None;
+        }
+        else {
+            return ((_b = window === null || window === void 0 ? void 0 : window.location) === null || _b === void 0 ? void 0 : _b.href) || None;
+        }
+    }
+    static defaultUser() {
+        if (core_util_1.isNode) {
+            const info = (0, os_1.userInfo)();
+            return info.username || (process.env.USERDOMAIN ? `${process.env.USERDOMAIN}\\${process.env.USERNAME}` : process.env.USERNAME) || None;
+        }
+        else {
+            return None;
+        }
+    }
+    static defaultVersion() {
+        var _a;
+        return this.formatHeader([
+            ["Kusto.JavaScript.Client", version_1.SDK_VERSION],
+            ["Runtime." + (core_util_1.isNode ? "Node" : "Browser"), (core_util_1.isNode ? process.version : (_a = window === null || window === void 0 ? void 0 : window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent) || None],
+        ]);
+    }
+    static escapeHeader(header) {
+        return `{${header.replace(ReplaceRegex, "_")}}`;
+    }
+    static formatHeader(args) {
+        return args
+            .filter(([key, val]) => key && val)
+            .map(([key, val]) => `${key}:${this.escapeHeader(val)}`)
+            .join("|");
+    }
+    static setConnectorDetails(name, version, app_name = null, app_version = null, send_user = false, override_user = null, additional_fields = null) {
+        const params = [["Kusto." + name, version]];
+        app_name = app_name || this.defaultApplication();
+        app_version = app_version || None;
+        params.push(["App." + this.escapeHeader(app_name), app_version]);
+        params.push(...(additional_fields || []));
+        let user = None;
+        if (send_user) {
+            user = override_user || this.defaultUser();
+        }
+        return new ClientDetails(this.formatHeader(params), user);
+    }
+    getHeaders() {
+        return {
+            "x-ms-client-version": this.versionForTracing,
+            "x-ms-app": this.applicationNameForTracing,
+            "x-ms-user": this.userNameForTracing,
+        };
+    }
+}
+exports.ClientDetails = ClientDetails;
+//# sourceMappingURL=clientDetails.js.map

package/{source → dist-esm/src}/clientRequestProperties.js

@@ -78,6 +78,19 @@ class ClientRequestProperties {
         const secondsStr = seconds < 10 ? `0${seconds}` : String(seconds);
         return `${hoursStr}:${minutesStr}:${secondsStr}.${milliseconds}`;
     }
+    getHeaders() {
+        const headers = {};
+        if (this.clientRequestId) {
+            headers["x-ms-client-request-id"] = this.clientRequestId;
+        }
+        if (this.user) {
+            headers["x-ms-user"] = this.user;
+        }
+        if (this.application) {
+            headers["x-ms-app"] = this.application;
+        }
+        return headers;
+    }
 }
 exports.ClientRequestProperties = ClientRequestProperties;
 exports.default = ClientRequestProperties;

package/dist-esm/src/cloudSettings.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudSettings = void 0;
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+const axios_1 = __importDefault(require("axios"));
+/**
+ * This class holds data for all cloud instances, and returns the specific data instance by parsing the dns suffix from a URL
+ */
+class CloudSettings {
+    constructor() {
+        this.METADATA_ENDPOINT = "/v1/rest/auth/metadata";
+        this.defaultCloudInfo = {
+            LoginEndpoint: process.env.AadAuthorityUri || "https://login.microsoftonline.com",
+            LoginMfaRequired: false,
+            KustoClientAppId: "db662dc1-0cfe-4e1c-a843-19a68e65be58",
+            KustoClientRedirectUri: "https://microsoft/kustoclient",
+            KustoServiceResourceId: "https://kusto.kusto.windows.net",
+            FirstPartyAuthorityUrl: "https://login.microsoftonline.com/f8cdef31-a31e-4b4a-93e4-5f571e91255a",
+        };
+        this.cloudCache = {};
+    }
+    static getInstance() {
+        return CloudSettings.instance;
+    }
+    async getCloudInfoForCluster(kustoUri) {
+        var _a;
+        if (kustoUri in this.cloudCache) {
+            return this.cloudCache[kustoUri];
+        }
+        try {
+            const response = await axios_1.default.get(kustoUri + this.METADATA_ENDPOINT);
+            if (response.status === 200) {
+                this.cloudCache[kustoUri] = response.data.AzureAD || this.defaultCloudInfo;
+            }
+            else {
+                throw new Error(`Kusto returned an invalid cloud metadata response - ${response}`);
+            }
+        }
+        catch (ex) {
+            if (axios_1.default.isAxiosError(ex) && ((_a = ex.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                // For now as long not all proxies implement the metadata endpoint, if no endpoint exists return public cloud data
+                this.cloudCache[kustoUri] = this.defaultCloudInfo;
+            }
+            else {
+                throw new Error(`Failed to get cloud info for cluster ${kustoUri} - ${ex}`);
+            }
+        }
+        return this.cloudCache[kustoUri];
+    }
+    static getAuthorityUri(cloudInfo, authorityId) {
+        return cloudInfo.LoginEndpoint + "/" + (authorityId || "organizations");
+    }
+}
+exports.CloudSettings = CloudSettings;
+CloudSettings.instance = new CloudSettings();
+//# sourceMappingURL=cloudSettings.js.map

package/dist-esm/src/connectionBuilder.browser.js

@@ -0,0 +1,72 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KustoConnectionStringBuilder = void 0;
+const connectionBuilderBase_1 = __importDefault(require("./connectionBuilderBase"));
+/* eslint-disable @typescript-eslint/no-unused-vars */
+class KustoConnectionStringBuilder extends connectionBuilderBase_1.default {
+    static withAadUserPasswordAuthentication(_connectionString, _userId, _password, _authorityId) {
+        throw new Error("Not supported in browser - use withUserPrompt instead");
+    }
+    static withAadApplicationKeyAuthentication(_connectionString, _aadAppId, _appKey, _authorityId) {
+        throw new Error("Not supported in browser - use withUserPrompt instead");
+    }
+    static withAadApplicationCertificateAuthentication(_connectionString, _aadAppId, _applicationCertificatePrivateKey, _authorityId, _applicationCertificateSendX5c) {
+        throw new Error("Not supported in browser - use withUserPrompt instead");
+    }
+    static withAadDeviceAuthentication(_connectionString, _authorityId, _deviceCodeCallback) {
+        throw new Error("Not supported in browser - use withUserPrompt instead");
+    }
+    static withSystemManagedIdentity(_connectionString, _authorityId, _timeoutMs) {
+        throw new Error("Not supported in browser - use withUserPrompt instead");
+    }
+    static withUserManagedIdentity(_connectionString, _msiClientId, _authorityId, _timeoutMs) {
+        throw new Error("Not supported in browser - use withUserPrompt instead");
+    }
+    static withAzLoginIdentity(_connectionString, _authorityId, _timeoutMs) {
+        throw new Error("Not supported in browser - use withUserPrompt instead");
+    }
+    static withAccessToken(connectionString, accessToken) {
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        kcsb.accessToken = accessToken;
+        return kcsb;
+    }
+    static withTokenProvider(connectionString, tokenProvider) {
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        kcsb.tokenProvider = tokenProvider;
+        return kcsb;
+    }
+    static withUserPrompt(connectionString, interactiveCredentialOptions, timeoutMs) {
+        if (!interactiveCredentialOptions) {
+            throw new Error("Invalid parameters - You must provide interactiveCredentialOptions={clientId: string, redirectUri:string} to authenticate with user prompt in browser.");
+        }
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        const { redirectUri, clientId, tenantId } = interactiveCredentialOptions;
+        if (!clientId) {
+            throw new Error("Invalid parameters - You must provide your SPA application client id to authenticate against");
+        }
+        if (!redirectUri) {
+            throw new Error("Invalid parameters - You must provide a redirectUri registered on the SPA app");
+        }
+        kcsb.interactiveCredentialOptions = interactiveCredentialOptions;
+        kcsb.aadFederatedSecurity = true;
+        kcsb.applicationClientId = clientId;
+        kcsb.useUserPromptAuth = true;
+        if (tenantId) {
+            kcsb.authorityId = tenantId;
+        }
+        kcsb.timeoutMs = timeoutMs;
+        return kcsb;
+    }
+}
+exports.KustoConnectionStringBuilder = KustoConnectionStringBuilder;
+KustoConnectionStringBuilder.DefaultDatabaseName = "NetDefaultDB";
+KustoConnectionStringBuilder.SecretReplacement = "****";
+exports.default = KustoConnectionStringBuilder;
+//# sourceMappingURL=connectionBuilder.browser.js.map

package/dist-esm/src/connectionBuilder.js

@@ -0,0 +1,128 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KustoConnectionStringBuilder = void 0;
+const connectionBuilderBase_1 = require("./connectionBuilderBase");
+/*
+ * A builder for Kusto connection strings
+ * For browsers use withUserPrompt or provide the token yourself using withTokenProvider
+ */
+class KustoConnectionStringBuilder extends connectionBuilderBase_1.KustoConnectionStringBuilderBase {
+    static withAadUserPasswordAuthentication(connectionString, userId, password, authorityId) {
+        if (userId.trim().length === 0)
+            throw new Error("Invalid user");
+        if (password.trim().length === 0)
+            throw new Error("Invalid password");
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        kcsb.aadUserId = userId;
+        kcsb.password = password;
+        if (authorityId) {
+            kcsb.authorityId = authorityId;
+        }
+        return kcsb;
+    }
+    static withAadApplicationKeyAuthentication(connectionString, aadAppId, appKey, authorityId) {
+        if (aadAppId.trim().length === 0)
+            throw new Error("Invalid app id");
+        if (appKey.trim().length === 0)
+            throw new Error("Invalid app key");
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        kcsb.applicationClientId = aadAppId;
+        kcsb.applicationKey = appKey;
+        if (authorityId) {
+            kcsb.authorityId = authorityId;
+        }
+        return kcsb;
+    }
+    static withAadApplicationCertificateAuthentication(connectionString, aadAppId, applicationCertificatePrivateKey, authorityId, applicationCertificateSendX5c) {
+        if (aadAppId.trim().length === 0)
+            throw new Error("Invalid app id");
+        if (applicationCertificatePrivateKey.trim().length === 0)
+            throw new Error("Invalid certificate");
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        kcsb.applicationClientId = aadAppId;
+        kcsb.applicationCertificatePrivateKey = applicationCertificatePrivateKey;
+        kcsb.applicationCertificateSendX5c = applicationCertificateSendX5c;
+        if (authorityId) {
+            kcsb.authorityId = authorityId;
+        }
+        return kcsb;
+    }
+    static withAadDeviceAuthentication(connectionString, authorityId, deviceCodeCallback) {
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        if (authorityId) {
+            kcsb.authorityId = authorityId;
+        }
+        kcsb.deviceCodeCallback = deviceCodeCallback;
+        kcsb.useDeviceCodeAuth = true;
+        return kcsb;
+    }
+    static withAadManagedIdentities(connectionString, msiClientId, authorityId, timeoutMs) {
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        if (authorityId) {
+            kcsb.authorityId = authorityId;
+        }
+        kcsb.msiClientId = msiClientId;
+        kcsb.timeoutMs = timeoutMs;
+        kcsb.useManagedIdentityAuth = true;
+        return kcsb;
+    }
+    static withSystemManagedIdentity(connectionString, authorityId, timeoutMs) {
+        return this.withAadManagedIdentities(connectionString, undefined, authorityId, timeoutMs);
+    }
+    static withUserManagedIdentity(connectionString, msiClientId, authorityId, timeoutMs) {
+        return this.withAadManagedIdentities(connectionString, msiClientId, authorityId, timeoutMs);
+    }
+    static withAzLoginIdentity(connectionString, authorityId, timeoutMs) {
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        kcsb.useAzLoginAuth = true;
+        if (authorityId) {
+            kcsb.authorityId = authorityId;
+        }
+        kcsb.timeoutMs = timeoutMs;
+        return kcsb;
+    }
+    static withAccessToken(connectionString, accessToken) {
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        kcsb.accessToken = accessToken;
+        return kcsb;
+    }
+    static withTokenProvider(connectionString, tokenProvider) {
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        kcsb.aadFederatedSecurity = true;
+        kcsb.tokenProvider = tokenProvider;
+        return kcsb;
+    }
+    /**
+     * Use InteractiveBrowserCredentialNodeOptions in Node.JS and InteractiveBrowserCredentialInBrowserOptions in browser
+     * For browser cors issue: you need to visit your app registration and update the redirect URI you're using to the type spa (for "single page application").
+     * See: https://github.com/Azure/azure-sdk-for-js/tree/main/sdk/identity/identity/test/manual/interactive-browser-credential
+     */
+    static withUserPrompt(connectionString, options, timeoutMs) {
+        const kcsb = new KustoConnectionStringBuilder(connectionString);
+        const { tenantId, clientId } = options || {};
+        if (clientId) {
+            throw new Error("clientId should be empty as it is retrived from the service management endpoint");
+        }
+        kcsb.aadFederatedSecurity = true;
+        kcsb.useUserPromptAuth = true;
+        if (tenantId) {
+            kcsb.authorityId = tenantId;
+        }
+        kcsb.timeoutMs = timeoutMs;
+        return kcsb;
+    }
+}
+exports.KustoConnectionStringBuilder = KustoConnectionStringBuilder;
+KustoConnectionStringBuilder.DefaultDatabaseName = "NetDefaultDB";
+KustoConnectionStringBuilder.SecretReplacement = "****";
+exports.default = KustoConnectionStringBuilder;
+//# sourceMappingURL=connectionBuilder.js.map