azure-kusto-data 4.0.3 → 5.0.0

package/dist-esm/src/connectionBuilderBase.js

@@ -0,0 +1,138 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KustoConnectionStringBuilderBase = exports.KeywordMapping = void 0;
+const clientDetails_1 = require("./clientDetails");
+exports.KeywordMapping = Object.freeze({
+    dataSource: {
+        mappedTo: "Data Source",
+        validNames: ["data source", "addr", "address", "network address", "server"],
+    },
+    aadFederatedSecurity: {
+        mappedTo: "AAD Federated Security",
+        validNames: ["aad federated security", "federated security", "federated", "fed", "aadfed"],
+        isBool: true,
+    },
+    initialCatalog: {
+        mappedTo: "Initial Catalog",
+        validNames: ["initial catalog", "database"],
+    },
+    aadUserId: {
+        mappedTo: "AAD User ID",
+        validNames: ["aad user id"],
+    },
+    password: {
+        mappedTo: "Password",
+        validNames: ["password", "pwd"],
+        isSecret: true,
+    },
+    applicationClientId: {
+        mappedTo: "Application Client Id",
+        validNames: ["application client id", "appclientid"],
+    },
+    applicationKey: {
+        mappedTo: "Application Key",
+        validNames: ["application key", "appkey"],
+        isSecret: true,
+    },
+    applicationCertificatePrivateKey: {
+        mappedTo: "Application Certificate PrivateKey",
+        validNames: ["Application Certificate PrivateKey"],
+        isSecret: true,
+    },
+    applicationCertificateSendX5c: {
+        mappedTo: "Application Certificate x5c",
+        validNames: ["application certificate x5c", "Application Certificate Send Public Certificate", "Application Certificate SendX5c", "SendX5c"],
+        isBool: true,
+    },
+    authorityId: {
+        mappedTo: "Authority Id",
+        validNames: ["authority id", "authorityid", "authority", "tenantid", "tenant", "tid"],
+    },
+});
+const getPropName = (key) => {
+    const _key = key.trim().toLowerCase();
+    for (const keyword of Object.keys(exports.KeywordMapping)) {
+        const k = exports.KeywordMapping[keyword];
+        if (!k) {
+            continue;
+        }
+        if (k.validNames.map((n) => n.trim().toLowerCase()).indexOf(_key) >= 0) {
+            return [keyword, k];
+        }
+    }
+    throw new Error("Failed to get prop: " + key);
+};
+class KustoConnectionStringBuilderBase {
+    constructor(connectionString) {
+        var _a;
+        this.authorityId = "organizations";
+        this.applicationNameForTracing = null;
+        this.userNameForTracing = null;
+        if (connectionString.trim().length === 0)
+            throw new Error("Missing connection string");
+        if (connectionString.endsWith("/") || connectionString.endsWith("\\")) {
+            connectionString = connectionString.slice(0, -1);
+        }
+        if (!!connectionString && connectionString.split(";")[0].indexOf("=") === -1) {
+            connectionString = "Data Source=" + connectionString;
+        }
+        const params = connectionString.split(";");
+        for (const item of params) {
+            const kvp = item.split("=");
+            const [mappingTypeName, mappingType] = getPropName(kvp[0]);
+            if (mappingType.isBool) {
+                this[mappingTypeName] = kvp[1].trim().toLowerCase() === "true";
+            }
+            else {
+                this[mappingTypeName] = (_a = kvp[1]) === null || _a === void 0 ? void 0 : _a.trim();
+            }
+        }
+        if (!this.initialCatalog) {
+            this.initialCatalog = KustoConnectionStringBuilderBase.DefaultDatabaseName;
+        }
+    }
+    clientDetails() {
+        return new clientDetails_1.ClientDetails(this.applicationNameForTracing, this.userNameForTracing);
+    }
+    /**
+     * Sets the connector details for tracing purposes.
+     *
+     * @param name  The name of the connector
+     * @param version  The version of the connector
+     * @param appName? The name of the containing application
+     * @param appVersion?? The version of the containing application
+     * @param sendUser Whether to send the username
+     * @param overrideUser?? Override the username ( if sendUser is True )
+     * @param additionalFields? Additional fields to add to the header
+     */
+    setConnectorDetails(name, version, appName, appVersion, sendUser = false, overrideUser, additionalFields) {
+        const clientDetails = clientDetails_1.ClientDetails.setConnectorDetails(name, version, appName, appVersion, sendUser, overrideUser, additionalFields);
+        this.applicationNameForTracing = clientDetails.applicationNameForTracing;
+        this.userNameForTracing = clientDetails.userNameForTracing;
+    }
+    toString(removeSecrets = true) {
+        return Object.entries(exports.KeywordMapping)
+            .map(([key, mappingType]) => {
+            const value = this[key];
+            if (!mappingType || value === undefined) {
+                return "";
+            }
+            if (mappingType.isSecret && removeSecrets) {
+                return `${mappingType.mappedTo}=${KustoConnectionStringBuilderBase.SecretReplacement}`;
+            }
+            return `${mappingType.mappedTo}=${value.toString()}`;
+        })
+            .filter((x) => x !== "")
+            .join(";");
+    }
+    static fromExisting(other) {
+        return Object.assign({}, other);
+    }
+}
+exports.KustoConnectionStringBuilderBase = KustoConnectionStringBuilderBase;
+KustoConnectionStringBuilderBase.DefaultDatabaseName = "NetDefaultDB";
+KustoConnectionStringBuilderBase.SecretReplacement = "****";
+exports.default = KustoConnectionStringBuilderBase;
+//# sourceMappingURL=connectionBuilderBase.js.map

package/{index.js → dist-esm/src/index.js}

@@ -28,13 +28,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KustoDataErrors = exports.KustoConnectionStringBuilder = exports.ClientRequestProperties = exports.Client = void 0;
-const client_1 = __importDefault(require("./source/client"));
+exports.TimeUtils = exports.KustoDataErrors = exports.KustoConnectionStringBuilder = exports.ClientRequestProperties = exports.Client = void 0;
+const client_1 = __importDefault(require("./client"));
 exports.Client = client_1.default;
-const clientRequestProperties_1 = __importDefault(require("./source/clientRequestProperties"));
+const clientRequestProperties_1 = __importDefault(require("./clientRequestProperties"));
 exports.ClientRequestProperties = clientRequestProperties_1.default;
-const connectionBuilder_1 = __importDefault(require("./source/connectionBuilder"));
+const connectionBuilder_1 = __importDefault(require("./connectionBuilder"));
 exports.KustoConnectionStringBuilder = connectionBuilder_1.default;
-const KustoDataErrors = __importStar(require("./source/errors"));
+const KustoDataErrors = __importStar(require("./errors"));
 exports.KustoDataErrors = KustoDataErrors;
+const timeUtils_1 = require("./timeUtils");
+const TimeUtils = { toMilliseconds: timeUtils_1.toMilliseconds };
+exports.TimeUtils = TimeUtils;
 //# sourceMappingURL=index.js.map

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

@@ -1,12 +1,9 @@
 "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.KustoResultTable = exports.KustoResultColumn = exports.KustoResultRow = exports.WellKnownDataSet = void 0;
-const moment_1 = __importDefault(require("moment"));
+const timeUtils_1 = require("./timeUtils");
 var WellKnownDataSet;
 (function (WellKnownDataSet) {
     WellKnownDataSet["PrimaryResult"] = "PrimaryResult";
@@ -14,8 +11,13 @@ var WellKnownDataSet;
     WellKnownDataSet["TableOfContents"] = "TableOfContents";
     WellKnownDataSet["QueryProperties"] = "QueryProperties";
 })(WellKnownDataSet = exports.WellKnownDataSet || (exports.WellKnownDataSet = {}));
-const defaultDatetimeParser = (t) => (0, moment_1.default)(t);
-const defaultTimespanParser = (t) => moment_1.default.duration(t);
+const defaultDatetimeParser = (t) => new Date(t);
+const defaultTimespanParser = timeUtils_1.parseKustoTimestampToMillis;
+/**
+ * Represents a Kusto result row.
+ * Use `dateTimeParser` and `timeSpanParser` to customize the parsing of the `datetime` and `timespan` types.
+ * By default, `datetime` is parsed to a `Date` object and `timespan` is parsed to a number representing the number of milliseconds, as returned by subtracting two `Date` objects.
+ */
 class KustoResultRow {
     constructor(columns, row, dateTimeParser = defaultDatetimeParser, timeSpanParser = defaultTimespanParser) {
         this.columns = columns.sort((a, b) => a.ordinal - b.ordinal);

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

@@ -22,20 +22,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AadHelper = void 0;
-require("./tokenProvider");
 const TokenProvider = __importStar(require("./tokenProvider"));
 const errors_1 = require("./errors");
+const tokenProvider_1 = require("./tokenProvider");
 class AadHelper {
     constructor(kcsb) {
         if (!kcsb.dataSource) {
@@ -47,8 +38,8 @@ class AadHelper {
         else if (!!kcsb.applicationClientId && !!kcsb.applicationKey) {
             this.tokenProvider = new TokenProvider.ApplicationKeyTokenProvider(kcsb.dataSource, kcsb.applicationClientId, kcsb.applicationKey, kcsb.authorityId);
         }
-        else if (!!kcsb.applicationClientId && !!kcsb.applicationCertificateThumbprint && !!kcsb.applicationCertificatePrivateKey) {
-            this.tokenProvider = new TokenProvider.ApplicationCertificateTokenProvider(kcsb.dataSource, kcsb.applicationClientId, kcsb.applicationCertificateThumbprint, kcsb.applicationCertificatePrivateKey, kcsb.applicationCertificateX5c, kcsb.authorityId);
+        else if (!!kcsb.applicationClientId && !!kcsb.applicationCertificatePrivateKey) {
+            this.tokenProvider = new TokenProvider.ApplicationCertificateTokenProvider(kcsb.dataSource, kcsb.applicationClientId, kcsb.applicationCertificatePrivateKey, kcsb.applicationCertificateSendX5c, kcsb.authorityId);
         }
         else if (kcsb.useManagedIdentityAuth) {
             this.tokenProvider = new TokenProvider.MsiTokenProvider(kcsb.dataSource, kcsb.msiClientId, kcsb.authorityId, kcsb.timeoutMs);
@@ -57,34 +48,29 @@ class AadHelper {
             this.tokenProvider = new TokenProvider.AzCliTokenProvider(kcsb.dataSource, kcsb.authorityId, kcsb.timeoutMs);
         }
         else if (kcsb.accessToken) {
-            this.tokenProvider = new TokenProvider.BasicTokenProvider(kcsb.dataSource, kcsb.accessToken);
+            this.tokenProvider = new tokenProvider_1.BasicTokenProvider(kcsb.dataSource, kcsb.accessToken);
         }
         else if (kcsb.useUserPromptAuth) {
-            this.tokenProvider = new TokenProvider.UserPromptProvider(kcsb.dataSource, kcsb.authorityId, kcsb.timeoutMs, kcsb.loginHint);
+            this.tokenProvider = new tokenProvider_1.UserPromptProvider(kcsb.dataSource, kcsb.interactiveCredentialOptions);
         }
         else if (kcsb.tokenProvider) {
-            this.tokenProvider = new TokenProvider.CallbackTokenProvider(kcsb.dataSource, kcsb.tokenProvider);
+            this.tokenProvider = new tokenProvider_1.CallbackTokenProvider(kcsb.dataSource, kcsb.tokenProvider);
         }
         else if (kcsb.useDeviceCodeAuth) {
-            if (kcsb.deviceCodeCallback === undefined) {
-                throw new errors_1.KustoAuthenticationError("Device code authentication requires a callback function", undefined, TokenProvider.DeviceLoginTokenProvider.name, {});
-            }
             this.tokenProvider = new TokenProvider.DeviceLoginTokenProvider(kcsb.dataSource, kcsb.deviceCodeCallback, kcsb.authorityId);
         }
     }
-    getAuthHeader() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.tokenProvider) {
-                return null;
-            }
-            try {
-                const token = yield this.tokenProvider.acquireToken();
-                return `${token.tokenType} ${token.accessToken}`;
-            }
-            catch (e) {
-                throw new errors_1.KustoAuthenticationError(e instanceof Error ? e.message : `${e}`, e instanceof Error ? e : undefined, this.tokenProvider.constructor.name, this.tokenProvider.context());
-            }
-        });
+    async getAuthHeader() {
+        if (!this.tokenProvider) {
+            return null;
+        }
+        try {
+            const token = await this.tokenProvider.acquireToken();
+            return `${token.tokenType} ${token.accessToken}`;
+        }
+        catch (e) {
+            throw new errors_1.KustoAuthenticationError(e instanceof Error ? e.message : `${e}`, e instanceof Error ? e : undefined, this.tokenProvider.constructor.name, this.tokenProvider.context());
+        }
     }
 }
 exports.AadHelper = AadHelper;

package/dist-esm/src/timeUtils.js

@@ -0,0 +1,28 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKustoTimestampToMillis = exports.toMilliseconds = void 0;
+function toMilliseconds(hours, minutes, seconds) {
+    return (hours * 60 * 60 + minutes * 60 + seconds) * 1000;
+}
+exports.toMilliseconds = toMilliseconds;
+// Format: [+|-]d.hh:mm:ss[.fffffff]
+const TimespanRegex = /^(-?)(?:(\d+).)?(\d{2}):(\d{2}):(\d{2}(\.\d+)?$)/;
+function parseKustoTimestampToMillis(t) {
+    if (t == null) {
+        return 0;
+    }
+    const match = TimespanRegex.exec(t);
+    if (match) {
+        const sign = match[1] === "-" ? -1 : 1;
+        const days = parseInt(match[2] || "0", 10);
+        const hours = parseInt(match[3], 10);
+        const minutes = parseInt(match[4], 10);
+        const seconds = parseFloat(match[5]);
+        return sign * 1000 * (days * 24 * 60 * 60 + hours * 60 * 60 + minutes * 60 + seconds);
+    }
+    throw new Error(`Timespan value '${t}' cannot be decoded`);
+}
+exports.parseKustoTimestampToMillis = parseKustoTimestampToMillis;
+//# sourceMappingURL=timeUtils.js.map

package/dist-esm/src/tokenProvider.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationKeyTokenProvider = exports.ApplicationCertificateTokenProvider = exports.DeviceLoginTokenProvider = exports.UserPassTokenProvider = exports.AzCliTokenProvider = exports.MsiTokenProvider = exports.UserPromptProvider = exports.AzureIdentityProvider = exports.CloudSettingsTokenProvider = exports.CallbackTokenProvider = exports.BasicTokenProvider = exports.TokenProviderBase = void 0;
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+const identity_1 = require("@azure/identity");
+const identity_2 = require("@azure/identity");
+const cloudSettings_1 = require("./cloudSettings");
+const BEARER_TYPE = "Bearer";
+/**
+ * This base class abstracts token acquisition for all implementations.
+ * The class is build for Lazy initialization, so that the first call, take on instantiation of 'heavy' long-lived class members
+ */
+class TokenProviderBase {
+    context() {
+        return {};
+    }
+    constructor(kustoUri) {
+        this.kustoUri = kustoUri;
+        if (kustoUri != null) {
+            const suffix = (!this.kustoUri.endsWith("/") ? "/" : "") + ".default";
+            this.scopes = [kustoUri + suffix];
+        }
+    }
+}
+exports.TokenProviderBase = TokenProviderBase;
+/**
+ * Basic Token Provider keeps and returns a token received on construction
+ */
+class BasicTokenProvider extends TokenProviderBase {
+    constructor(kustoUri, token) {
+        super(kustoUri);
+        this.token = token;
+    }
+    acquireToken() {
+        return Promise.resolve({
+            tokenType: BEARER_TYPE,
+            accessToken: this.token,
+        });
+    }
+}
+exports.BasicTokenProvider = BasicTokenProvider;
+/**
+ * Callback Token Provider generates a token based on a callback function provided by the caller
+ */
+class CallbackTokenProvider extends TokenProviderBase {
+    constructor(kustoUri, callback) {
+        super(kustoUri);
+        this.callback = callback;
+    }
+    async acquireToken() {
+        const token = await this.callback();
+        return { tokenType: BEARER_TYPE, accessToken: token };
+    }
+}
+exports.CallbackTokenProvider = CallbackTokenProvider;
+/**
+ * Token providers that require cloud settings to be configured - msal and azure identity
+ */
+class CloudSettingsTokenProvider extends TokenProviderBase {
+    additionalCloudSettingsInit() { }
+    constructor(kustoUri) {
+        super(kustoUri);
+        this.initialized = false;
+    }
+    async acquireToken() {
+        if (!this.initialized) {
+            if (this.cloudInfo == null) {
+                this.cloudInfo = await cloudSettings_1.CloudSettings.getInstance().getCloudInfoForCluster(this.kustoUri);
+                let resourceUri = this.cloudInfo.KustoServiceResourceId;
+                if (this.cloudInfo.LoginMfaRequired) {
+                    resourceUri = resourceUri.replace(".kusto.", ".kustomfa.");
+                }
+                this.scopes = [resourceUri + "/.default"];
+                this.additionalCloudSettingsInit();
+                this.initClient();
+            }
+            this.initialized = true;
+        }
+        const token = await this.acquireTokenWithCloudSettings();
+        if (token) {
+            return { tokenType: token.tokenType, accessToken: token.accessToken };
+        }
+        throw new Error("Failed to get token from msal");
+    }
+    context() {
+        return Object.assign(Object.assign({}, super.context()), { kustoUri: this.kustoUri });
+    }
+}
+exports.CloudSettingsTokenProvider = CloudSettingsTokenProvider;
+class AzureIdentityProvider extends CloudSettingsTokenProvider {
+    constructor(kustoUri, authorityId, timeoutMs) {
+        super(kustoUri);
+        this.authorityId = authorityId;
+        this.timeoutMs = timeoutMs;
+    }
+    initClient() {
+        this.credential = this.getCredential();
+    }
+    async acquireTokenWithCloudSettings() {
+        const response = await this.credential.getToken(this.scopes, {
+            requestOptions: {
+                timeout: this.timeoutMs,
+            },
+            tenantId: this.authorityId,
+        });
+        if (response === null) {
+            throw new Error("Failed to get token from msal");
+        }
+        return { tokenType: BEARER_TYPE, accessToken: response.token };
+    }
+    context() {
+        let base = Object.assign(Object.assign({}, super.context()), { kustoUri: this.kustoUri, authorityId: this.authorityId });
+        if (this.timeoutMs) {
+            base = Object.assign(Object.assign({}, base), { timeoutMs: this.timeoutMs });
+        }
+        return base;
+    }
+}
+exports.AzureIdentityProvider = AzureIdentityProvider;
+/**
+ * UserPromptProvider will pop up a login prompt to acquire a token.
+ */
+class UserPromptProvider extends AzureIdentityProvider {
+    constructor(kustoUri, interactiveCredentialOptions, timeoutMs) {
+        super(kustoUri, interactiveCredentialOptions === null || interactiveCredentialOptions === void 0 ? void 0 : interactiveCredentialOptions.tenantId, timeoutMs);
+        this.interactiveCredentialOptions = interactiveCredentialOptions;
+        // The default port is 80, which can lead to permission errors, so we'll choose another port
+        this.MinPort = 20000;
+        this.MaxPort = 65536;
+    }
+    getCredential() {
+        var _a, _b, _c, _d;
+        return new identity_2.InteractiveBrowserCredential(Object.assign(Object.assign({}, this.interactiveCredentialOptions), { tenantId: this.authorityId, clientId: (_b = (_a = this.interactiveCredentialOptions) === null || _a === void 0 ? void 0 : _a.clientId) !== null && _b !== void 0 ? _b : this.cloudInfo.KustoClientAppId, redirectUri: (_d = (_c = this.interactiveCredentialOptions) === null || _c === void 0 ? void 0 : _c.redirectUri) !== null && _d !== void 0 ? _d : `http://localhost:${this.getRandomPortInRange()}/` }));
+    }
+    getRandomPortInRange() {
+        return Math.floor(Math.random() * (this.MaxPort - this.MinPort) + this.MinPort);
+    }
+    context() {
+        var _a, _b;
+        let base = super.context();
+        if ((_a = this.interactiveCredentialOptions) === null || _a === void 0 ? void 0 : _a.loginHint) {
+            base = Object.assign(Object.assign({}, base), { loginHint: (_b = this.interactiveCredentialOptions) === null || _b === void 0 ? void 0 : _b.loginHint });
+        }
+        return base;
+    }
+}
+exports.UserPromptProvider = UserPromptProvider;
+/**
+ * MSI Token Provider obtains a token from the MSI endpoint
+ * The args parameter is a dictionary conforming with the ManagedIdentityCredential initializer API arguments
+ */
+class MsiTokenProvider extends AzureIdentityProvider {
+    constructor(kustoUri, clientId, authorityId, timeoutMs) {
+        super(kustoUri, authorityId, timeoutMs);
+        this.clientId = clientId;
+    }
+    getCredential() {
+        return this.clientId ? new identity_1.ManagedIdentityCredential(this.clientId) : new identity_1.ManagedIdentityCredential();
+    }
+    context() {
+        return Object.assign(Object.assign({}, super.context()), { clientId: this.clientId });
+    }
+}
+exports.MsiTokenProvider = MsiTokenProvider;
+/**
+ * AzCli Token Provider obtains a refresh token from the AzCli cache and uses it to authenticate with MSAL
+ */
+class AzCliTokenProvider extends AzureIdentityProvider {
+    getCredential() {
+        return new identity_1.AzureCliCredential();
+    }
+}
+exports.AzCliTokenProvider = AzCliTokenProvider;
+/**
+ * Acquire a token from MSAL with username and password
+ */
+class UserPassTokenProvider extends AzureIdentityProvider {
+    constructor(kustoUri, userName, password, authorityId) {
+        super(kustoUri, authorityId, undefined);
+        this.userName = userName;
+        this.password = password;
+    }
+    getCredential() {
+        return new identity_1.UsernamePasswordCredential(this.authorityId, this.cloudInfo.KustoClientAppId, this.userName, this.password);
+    }
+    context() {
+        return Object.assign(Object.assign({}, super.context()), { userName: this.userName, homeAccountId: this.homeAccountId });
+    }
+}
+exports.UserPassTokenProvider = UserPassTokenProvider;
+/**
+ * Acquire a token from  Device Login flow
+ */
+class DeviceLoginTokenProvider extends AzureIdentityProvider {
+    constructor(kustoUri, deviceCodeCallback, authorityId) {
+        super(kustoUri, authorityId, undefined);
+        this.deviceCodeCallback = deviceCodeCallback;
+    }
+    getCredential() {
+        return new identity_1.DeviceCodeCredential({
+            tenantId: this.authorityId,
+            clientId: this.cloudInfo.KustoClientAppId,
+            userPromptCallback: this.deviceCodeCallback,
+        });
+    }
+}
+exports.DeviceLoginTokenProvider = DeviceLoginTokenProvider;
+/**
+ * Acquire a token from MSAL using application certificate
+ * Passing the public certificate is optional and will result in Subject Name & Issuer Authentication
+ */
+class ApplicationCertificateTokenProvider extends AzureIdentityProvider {
+    constructor(kustoUri, appClientId, certPrivateKey, sendX5c, authorityId) {
+        super(kustoUri, authorityId);
+        this.appClientId = appClientId;
+        this.certPrivateKey = certPrivateKey;
+        this.sendX5c = sendX5c;
+    }
+    getCredential() {
+        return new identity_1.ClientCertificateCredential(this.authorityId, this.appClientId, {
+            certificate: this.certPrivateKey,
+        }, {
+            sendCertificateChain: this.sendX5c,
+        });
+    }
+    context() {
+        return Object.assign(Object.assign({}, super.context()), { clientId: this.appClientId, sendX5c: this.sendX5c });
+    }
+}
+exports.ApplicationCertificateTokenProvider = ApplicationCertificateTokenProvider;
+/**
+ * Acquire a token from MSAL with application id and Key
+ */
+class ApplicationKeyTokenProvider extends AzureIdentityProvider {
+    constructor(kustoUri, appClientId, appKey, authorityId) {
+        super(kustoUri, authorityId);
+        this.appClientId = appClientId;
+        this.appKey = appKey;
+    }
+    getCredential() {
+        return new identity_1.ClientSecretCredential(this.authorityId, // The tenant ID in Azure Active Directory
+        this.appClientId, // The app registration client Id in the AAD tenant
+        this.appKey // The app registration secret for the registered application
+        );
+    }
+    context() {
+        return Object.assign(Object.assign({}, super.context()), { clientId: this.appClientId });
+    }
+}
+exports.ApplicationKeyTokenProvider = ApplicationKeyTokenProvider;
+//# sourceMappingURL=tokenProvider.js.map

package/dist-esm/src/version.js

@@ -0,0 +1,8 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+// SDK_VERSION should be updated in all 3 package.json and lerna.json(by running lerna version)
+exports.SDK_VERSION = "5.0.0";
+//# sourceMappingURL=version.js.map