plugin-data-source-mssql 2.0.10 → 2.0.12

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/logger/Logger.ts

@@ -0,0 +1,407 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { LoggerOptions } from "../config/ClientConfiguration.js";
+
+/**
+ * Options for logger messages.
+ */
+export type LoggerMessageOptions = {
+    logLevel: LogLevel;
+    containsPii?: boolean;
+    context?: string;
+    correlationId: string;
+};
+
+/**
+ * Log message level.
+ */
+export enum LogLevel {
+    Error,
+    Warning,
+    Info,
+    Verbose,
+    Trace,
+}
+
+/**
+ * Callback to send the messages to.
+ */
+export interface ILoggerCallback {
+    (level: LogLevel, message: string, containsPii: boolean): void;
+}
+
+/**
+ * Represents a single logged message with metadata
+ */
+export interface LoggedMessage {
+    hash: string;
+    level: LogLevel;
+    containsPii: boolean;
+    milliseconds: number;
+}
+
+/**
+ * LRU cache node for correlation ID management
+ */
+interface CorrelationLogData {
+    logs: LoggedMessage[];
+    firstEventTime: number;
+}
+
+// Shared cache state for better minification - using Map's insertion order for LRU
+const CACHE_CAPACITY = 50;
+const MAX_LOGS_PER_CORRELATION = 500;
+const correlationCache = new Map<string, CorrelationLogData>();
+
+/**
+ * Mark correlation ID as recently used by moving it to end of Map
+ * @param correlationId
+ * @param {CorrelationLogData} data
+ */
+function markAsRecentlyUsed(
+    correlationId: string,
+    data: CorrelationLogData
+): void {
+    correlationCache.delete(correlationId);
+    correlationCache.set(correlationId, data);
+}
+
+/**
+ * Add log message to cache for specific correlation ID
+ * @param correlationId
+ * @param {LoggedMessage} loggedMessage
+ */
+function addLogToCache(
+    correlationId: string,
+    loggedMessage: LoggedMessage
+): void {
+    const currentTime = Date.now();
+
+    let data = correlationCache.get(correlationId);
+
+    if (data) {
+        // Mark as recently used
+        markAsRecentlyUsed(correlationId, data);
+    } else {
+        // Create new entry
+        data = { logs: [], firstEventTime: currentTime };
+        correlationCache.set(correlationId, data);
+
+        // Remove LRU (first entry) if capacity exceeded
+        if (correlationCache.size > CACHE_CAPACITY) {
+            const firstKey = correlationCache.keys().next().value;
+            if (firstKey) {
+                correlationCache.delete(firstKey);
+            }
+        }
+    }
+
+    // Add log to the data, maintaining max logs per correlation
+    data.logs.push({
+        ...loggedMessage,
+        milliseconds: currentTime - data.firstEventTime,
+    });
+    if (data.logs.length > MAX_LOGS_PER_CORRELATION) {
+        data.logs.shift(); // Remove oldest log
+    }
+}
+
+/**
+ * Get all logs for specific correlation ID
+ * @param correlationId
+ */
+export function getLogsFromCache(correlationId: string): LoggedMessage[] {
+    const data = correlationCache.get(correlationId);
+    if (data) {
+        markAsRecentlyUsed(correlationId, data);
+        return [...data.logs]; // Return copy
+    }
+    return [];
+}
+
+/**
+ * Get logs for correlation ID and flush them from cache
+ * Attaches logs with empty correlation id to the requested correlation logs
+ * @param correlationId
+ */
+export function getAndFlushLogsFromCache(
+    correlationId: string
+): LoggedMessage[] {
+    const res: LoggedMessage[] = [];
+    for (const id of ["", correlationId]) {
+        const data = correlationCache.get(id);
+        res.push(...(data?.logs ?? []));
+        correlationCache.delete(id); // Remove the correlation ID completely from cache
+    }
+    return res;
+}
+
+/**
+ * Get all correlation IDs that have logs
+ */
+export function getCachedCorrelationIds(): string[] {
+    return Array.from(correlationCache.keys());
+}
+
+/**
+ * Checks if a string is already a hashed logging string (6 alphanumeric characters)
+ */
+function isHashedString(str: string): boolean {
+    if (str.length !== 6) {
+        return false;
+    }
+
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const isAlphaNumeric =
+            (char >= "a" && char <= "z") ||
+            (char >= "A" && char <= "Z") ||
+            (char >= "0" && char <= "9");
+        if (!isAlphaNumeric) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * Class which facilitates logging of messages to a specific place.
+ */
+export class Logger {
+    // Current log level, defaults to info.
+    private level: LogLevel = LogLevel.Info;
+
+    // Boolean describing whether PII logging is allowed.
+    private piiLoggingEnabled: boolean;
+
+    // Callback to send messages to.
+    private localCallback: ILoggerCallback;
+
+    // Package name implementing this logger
+    private packageName: string;
+
+    // Package version implementing this logger
+    private packageVersion: string;
+
+    constructor(
+        loggerOptions: LoggerOptions,
+        packageName?: string,
+        packageVersion?: string
+    ) {
+        const defaultLoggerCallback = () => {
+            return;
+        };
+        const setLoggerOptions =
+            loggerOptions || Logger.createDefaultLoggerOptions();
+        this.localCallback =
+            setLoggerOptions.loggerCallback || defaultLoggerCallback;
+        this.piiLoggingEnabled = setLoggerOptions.piiLoggingEnabled || false;
+        this.level =
+            typeof setLoggerOptions.logLevel === "number"
+                ? setLoggerOptions.logLevel
+                : LogLevel.Info;
+        this.packageName = packageName || "";
+        this.packageVersion = packageVersion || "";
+    }
+
+    private static createDefaultLoggerOptions(): LoggerOptions {
+        return {
+            loggerCallback: () => {
+                // allow users to not set loggerCallback
+            },
+            piiLoggingEnabled: false,
+            logLevel: LogLevel.Info,
+        };
+    }
+
+    /**
+     * Create new Logger with existing configurations.
+     */
+    public clone(packageName: string, packageVersion: string): Logger {
+        return new Logger(
+            {
+                loggerCallback: this.localCallback,
+                piiLoggingEnabled: this.piiLoggingEnabled,
+                logLevel: this.level,
+            },
+            packageName,
+            packageVersion
+        );
+    }
+
+    /**
+     * Log message with required options.
+     */
+    private logMessage(
+        logMessage: string,
+        options: LoggerMessageOptions
+    ): void {
+        const correlationId = options.correlationId;
+        const isHashedInput = isHashedString(logMessage);
+
+        if (isHashedInput) {
+            const loggedMessage: LoggedMessage = {
+                hash: logMessage,
+                level: options.logLevel,
+                containsPii: options.containsPii || false,
+                milliseconds: 0, // Will be calculated in addLogToCache
+            };
+            addLogToCache(correlationId, loggedMessage);
+        }
+
+        if (
+            options.logLevel > this.level ||
+            (!this.piiLoggingEnabled && options.containsPii)
+        ) {
+            return;
+        }
+        const timestamp = new Date().toUTCString();
+
+        // Add correlationId to logs if set, correlationId provided on log messages take precedence
+        const logHeader = `[${timestamp}] : [${correlationId}]`;
+
+        const log = `${logHeader} : ${this.packageName}@${
+            this.packageVersion
+        } : ${LogLevel[options.logLevel]} - ${logMessage}`;
+
+        this.executeCallback(
+            options.logLevel,
+            log,
+            options.containsPii || false
+        );
+    }
+
+    /**
+     * Execute callback with message.
+     */
+    executeCallback(
+        level: LogLevel,
+        message: string,
+        containsPii: boolean
+    ): void {
+        if (this.localCallback) {
+            this.localCallback(level, message, containsPii);
+        }
+    }
+
+    /**
+     * Logs error messages.
+     */
+    error(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Error,
+            containsPii: false,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs error messages with PII.
+     */
+    errorPii(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Error,
+            containsPii: true,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs warning messages.
+     */
+    warning(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Warning,
+            containsPii: false,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs warning messages with PII.
+     */
+    warningPii(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Warning,
+            containsPii: true,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs info messages.
+     */
+    info(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Info,
+            containsPii: false,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs info messages with PII.
+     */
+    infoPii(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Info,
+            containsPii: true,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs verbose messages.
+     */
+    verbose(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Verbose,
+            containsPii: false,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs verbose messages with PII.
+     */
+    verbosePii(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Verbose,
+            containsPii: true,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs trace messages.
+     */
+    trace(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Trace,
+            containsPii: false,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Logs trace messages with PII.
+     */
+    tracePii(message: string, correlationId: string): void {
+        this.logMessage(message, {
+            logLevel: LogLevel.Trace,
+            containsPii: true,
+            correlationId: correlationId,
+        });
+    }
+
+    /**
+     * Returns whether PII Logging is enabled or not.
+     */
+    isPiiLoggingEnabled(): boolean {
+        return this.piiLoggingEnabled || false;
+    }
+}

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/network/INetworkModule.ts

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError.js";
+import { NetworkResponse } from "./NetworkResponse.js";
+
+/**
+ * Options allowed by network request APIs.
+ */
+export type NetworkRequestOptions = {
+    headers?: Record<string, string>;
+    body?: string;
+};
+
+/**
+ * Client network interface to send backend requests.
+ * @interface
+ */
+export interface INetworkModule {
+    /**
+     * Interface function for async network "GET" requests. Based on the Fetch standard: https://fetch.spec.whatwg.org/
+     * @param url
+     * @param options - Headers and/or body to include on the request
+     * @param timeout
+     */
+    sendGetRequestAsync<T>(
+        url: string,
+        options?: NetworkRequestOptions,
+        timeout?: number
+    ): Promise<NetworkResponse<T>>;
+
+    /**
+     * Interface function for async network "POST" requests. Based on the Fetch standard: https://fetch.spec.whatwg.org/
+     * @param url
+     * @param options - Headers and/or body to include on the request
+     */
+    sendPostRequestAsync<T>(
+        url: string,
+        options?: NetworkRequestOptions
+    ): Promise<NetworkResponse<T>>;
+}
+
+export const StubbedNetworkModule: INetworkModule = {
+    sendGetRequestAsync: () => {
+        return Promise.reject(
+            createClientAuthError(ClientAuthErrorCodes.methodNotImplemented)
+        );
+    },
+    sendPostRequestAsync: () => {
+        return Promise.reject(
+            createClientAuthError(ClientAuthErrorCodes.methodNotImplemented)
+        );
+    },
+};

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/network/NetworkResponse.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export type NetworkResponse<T> = {
+    headers: Record<string, string>;
+    body: T;
+    status: number;
+};

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/network/RequestThumbprint.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ShrOptions } from "../crypto/SignedHttpRequest.js";
+import { BaseAuthRequest } from "../request/BaseAuthRequest.js";
+import { AuthenticationScheme } from "../utils/Constants.js";
+
+/**
+ * Type representing a unique request thumbprint.
+ */
+export type RequestThumbprint = {
+    clientId: string;
+    authority: string;
+    scopes: Array<string>;
+    homeAccountIdentifier?: string;
+    claims?: string;
+    authenticationScheme?: AuthenticationScheme;
+    resourceRequestMethod?: string;
+    resourceRequestUri?: string;
+    shrClaims?: string;
+    sshKid?: string;
+    shrOptions?: ShrOptions;
+    embeddedClientId?: string;
+};
+
+export function getRequestThumbprint(
+    clientId: string,
+    request: BaseAuthRequest,
+    homeAccountId?: string
+): RequestThumbprint {
+    return {
+        clientId: clientId,
+        authority: request.authority,
+        scopes: request.scopes,
+        homeAccountIdentifier: homeAccountId,
+        claims: request.claims,
+        authenticationScheme: request.authenticationScheme,
+        resourceRequestMethod: request.resourceRequestMethod,
+        resourceRequestUri: request.resourceRequestUri,
+        shrClaims: request.shrClaims,
+        sshKid: request.sshKid,
+        embeddedClientId:
+            request.embeddedClientId || request.extraParameters?.clientId,
+    };
+}

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/network/ThrottlingUtils.ts

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { NetworkResponse } from "./NetworkResponse.js";
+import { ServerAuthorizationTokenResponse } from "../response/ServerAuthorizationTokenResponse.js";
+import * as Constants from "../utils/Constants.js";
+import { CacheManager } from "../cache/CacheManager.js";
+import { ServerError } from "../error/ServerError.js";
+import {
+    getRequestThumbprint,
+    RequestThumbprint,
+} from "./RequestThumbprint.js";
+import { ThrottlingEntity } from "../cache/entities/ThrottlingEntity.js";
+import { BaseAuthRequest } from "../request/BaseAuthRequest.js";
+
+/** @internal */
+export class ThrottlingUtils {
+    /**
+     * Prepares a RequestThumbprint to be stored as a key.
+     * @param thumbprint
+     */
+    static generateThrottlingStorageKey(thumbprint: RequestThumbprint): string {
+        return `${Constants.THROTTLING_PREFIX}.${JSON.stringify(thumbprint)}`;
+    }
+
+    /**
+     * Performs necessary throttling checks before a network request.
+     * @param cacheManager
+     * @param thumbprint
+     */
+    static preProcess(
+        cacheManager: CacheManager,
+        thumbprint: RequestThumbprint,
+        correlationId: string
+    ): void {
+        const key = ThrottlingUtils.generateThrottlingStorageKey(thumbprint);
+        const value = cacheManager.getThrottlingCache(key, correlationId);
+
+        if (value) {
+            if (value.throttleTime < Date.now()) {
+                cacheManager.removeItem(key, correlationId);
+                return;
+            }
+            throw new ServerError(
+                value.errorCodes?.join(" ") || "",
+                value.errorMessage,
+                value.subError
+            );
+        }
+    }
+
+    /**
+     * Performs necessary throttling checks after a network request.
+     * @param cacheManager
+     * @param thumbprint
+     * @param response
+     */
+    static postProcess(
+        cacheManager: CacheManager,
+        thumbprint: RequestThumbprint,
+        response: NetworkResponse<ServerAuthorizationTokenResponse>,
+        correlationId: string
+    ): void {
+        if (
+            ThrottlingUtils.checkResponseStatus(response) ||
+            ThrottlingUtils.checkResponseForRetryAfter(response)
+        ) {
+            const thumbprintValue: ThrottlingEntity = {
+                throttleTime: ThrottlingUtils.calculateThrottleTime(
+                    parseInt(
+                        response.headers[Constants.HeaderNames.RETRY_AFTER]
+                    )
+                ),
+                error: response.body.error,
+                errorCodes: response.body.error_codes,
+                errorMessage: response.body.error_description,
+                subError: response.body.suberror,
+            };
+            cacheManager.setThrottlingCache(
+                ThrottlingUtils.generateThrottlingStorageKey(thumbprint),
+                thumbprintValue,
+                correlationId
+            );
+        }
+    }
+
+    /**
+     * Checks a NetworkResponse object's status codes against 429 or 5xx
+     * @param response
+     */
+    static checkResponseStatus(
+        response: NetworkResponse<ServerAuthorizationTokenResponse>
+    ): boolean {
+        return (
+            response.status === 429 ||
+            (response.status >= 500 && response.status < 600)
+        );
+    }
+
+    /**
+     * Checks a NetworkResponse object's RetryAfter header
+     * @param response
+     */
+    static checkResponseForRetryAfter(
+        response: NetworkResponse<ServerAuthorizationTokenResponse>
+    ): boolean {
+        if (response.headers) {
+            return (
+                response.headers.hasOwnProperty(
+                    Constants.HeaderNames.RETRY_AFTER
+                ) &&
+                (response.status < 200 || response.status >= 300)
+            );
+        }
+        return false;
+    }
+
+    /**
+     * Calculates the Unix-time value for a throttle to expire given throttleTime in seconds.
+     * @param throttleTime
+     */
+    static calculateThrottleTime(throttleTime: number): number {
+        const time = throttleTime <= 0 ? 0 : throttleTime;
+
+        const currentSeconds = Date.now() / 1000;
+        return Math.floor(
+            Math.min(
+                currentSeconds +
+                    (time || Constants.DEFAULT_THROTTLE_TIME_SECONDS),
+                currentSeconds + Constants.DEFAULT_MAX_THROTTLE_TIME_SECONDS
+            ) * 1000
+        );
+    }
+
+    static removeThrottle(
+        cacheManager: CacheManager,
+        clientId: string,
+        request: BaseAuthRequest,
+        homeAccountIdentifier?: string
+    ): void {
+        const thumbprint = getRequestThumbprint(
+            clientId,
+            request,
+            homeAccountIdentifier
+        );
+        const key = this.generateThrottlingStorageKey(thumbprint);
+        cacheManager.removeItem(key, request.correlationId);
+    }
+}

package/dist/tedious/node_modules/@azure/msal-browser/node_modules/@azure/msal-common/src/packageMetadata.ts

@@ -0,0 +1,3 @@
+/* eslint-disable header/header */
+export const name = "@azure/msal-common";
+export const version = "16.6.1";