@azure/msal-node-extensions 1.0.0-alpha.12 → 1.0.0-alpha.13

package/src/error/PersistenceError.ts

@@ -1,101 +1,101 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Error thrown when trying to write MSAL cache to persistence.
- */
-export class PersistenceError extends Error {
-
-    // Short string denoting error
-    errorCode: string;
-    // Detailed description of error
-    errorMessage: string;
-
-    constructor(errorCode: string, errorMessage: string) {
-        const errorString = errorMessage ? `${errorCode}: ${errorMessage}` : errorCode;
-        super(errorString);
-        Object.setPrototypeOf(this, PersistenceError.prototype);
-
-        this.errorCode = errorCode;
-        this.errorMessage = errorMessage;
-        this.name = "PersistenceError";
-    }
-
-    /**
-     * Error thrown when trying to access the file system.
-     */
-    static createFileSystemError(errorCode: string, errorMessage: string): PersistenceError {
-        return new PersistenceError(errorCode, errorMessage);
-    }
-
-    /**
-     * Error thrown when trying to write, load, or delete data from secret service on linux.
-     * Libsecret is used to access secret service.
-     */
-    static createLibSecretError(errorMessage: string): PersistenceError {
-        return new PersistenceError("GnomeKeyringError", errorMessage);
-    }
-
-    /**
-     * Error thrown when trying to write, load, or delete data from keychain on macOs.
-     */
-    static createKeychainPersistenceError(errorMessage: string): PersistenceError {
-        return new PersistenceError("KeychainError", errorMessage);
-    }
-
-    /**
-     * Error thrown when trying to encrypt or decrypt data using DPAPI on Windows.
-     */
-    static createFilePersistenceWithDPAPIError(errorMessage: string): PersistenceError {
-        return new PersistenceError("DPAPIEncryptedFileError", errorMessage);
-    }
-
-    /**
-     * Error thrown when using the cross platform lock.
-     */
-    static createCrossPlatformLockError(errorMessage: string): PersistenceError {
-        return new PersistenceError("CrossPlatformLockError", errorMessage);
-    }
-
-    /**
-     * Throw cache persistence error
-     * 
-     * @param errorMessage string
-     * @returns PersistenceError
-     */
-    static createCachePersistenceError(errorMessage: string): PersistenceError {
-        return new PersistenceError("CachePersistenceError", errorMessage);
-    }
-
-    /**
-     * Throw unsupported error
-     * 
-     * @param errorMessage string
-     * @returns PersistenceError
-     */
-    static createNotSupportedError(errorMessage: string): PersistenceError {
-        return new PersistenceError("NotSupportedError", errorMessage);
-    }
-
-    /**
-     * Throw persistence not verified error
-     * 
-     * @param errorMessage string
-     * @returns PersistenceError
-     */
-    static createPersistenceNotVerifiedError(errorMessage: string): PersistenceError {
-        return new PersistenceError("PersistenceNotVerifiedError", errorMessage);
-    }
-
-    /**
-     * Throw persistence creation validation error
-     * 
-     * @param errorMessage string
-     * @returns PersistenceError
-     */
-    static createPersistenceNotValidatedError(errorMessage: string): PersistenceError {
-        return new PersistenceError("PersistenceNotValidatedError", errorMessage);
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Error thrown when trying to write MSAL cache to persistence.
+ */
+export class PersistenceError extends Error {
+
+    // Short string denoting error
+    errorCode: string;
+    // Detailed description of error
+    errorMessage: string;
+
+    constructor(errorCode: string, errorMessage: string) {
+        const errorString = errorMessage ? `${errorCode}: ${errorMessage}` : errorCode;
+        super(errorString);
+        Object.setPrototypeOf(this, PersistenceError.prototype);
+
+        this.errorCode = errorCode;
+        this.errorMessage = errorMessage;
+        this.name = "PersistenceError";
+    }
+
+    /**
+     * Error thrown when trying to access the file system.
+     */
+    static createFileSystemError(errorCode: string, errorMessage: string): PersistenceError {
+        return new PersistenceError(errorCode, errorMessage);
+    }
+
+    /**
+     * Error thrown when trying to write, load, or delete data from secret service on linux.
+     * Libsecret is used to access secret service.
+     */
+    static createLibSecretError(errorMessage: string): PersistenceError {
+        return new PersistenceError("GnomeKeyringError", errorMessage);
+    }
+
+    /**
+     * Error thrown when trying to write, load, or delete data from keychain on macOs.
+     */
+    static createKeychainPersistenceError(errorMessage: string): PersistenceError {
+        return new PersistenceError("KeychainError", errorMessage);
+    }
+
+    /**
+     * Error thrown when trying to encrypt or decrypt data using DPAPI on Windows.
+     */
+    static createFilePersistenceWithDPAPIError(errorMessage: string): PersistenceError {
+        return new PersistenceError("DPAPIEncryptedFileError", errorMessage);
+    }
+
+    /**
+     * Error thrown when using the cross platform lock.
+     */
+    static createCrossPlatformLockError(errorMessage: string): PersistenceError {
+        return new PersistenceError("CrossPlatformLockError", errorMessage);
+    }
+
+    /**
+     * Throw cache persistence error
+     * 
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createCachePersistenceError(errorMessage: string): PersistenceError {
+        return new PersistenceError("CachePersistenceError", errorMessage);
+    }
+
+    /**
+     * Throw unsupported error
+     * 
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createNotSupportedError(errorMessage: string): PersistenceError {
+        return new PersistenceError("NotSupportedError", errorMessage);
+    }
+
+    /**
+     * Throw persistence not verified error
+     * 
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createPersistenceNotVerifiedError(errorMessage: string): PersistenceError {
+        return new PersistenceError("PersistenceNotVerifiedError", errorMessage);
+    }
+
+    /**
+     * Throw persistence creation validation error
+     * 
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createPersistenceNotValidatedError(errorMessage: string): PersistenceError {
+        return new PersistenceError("PersistenceNotValidatedError", errorMessage);
+    }
+}

package/src/index.ts

@@ -1,16 +1,16 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-export { PersistenceCachePlugin } from "./persistence/PersistenceCachePlugin";
-export { FilePersistence } from "./persistence/FilePersistence";
-export { FilePersistenceWithDataProtection } from "./persistence/FilePersistenceWithDataProtection";
-export { DataProtectionScope } from "./persistence/DataProtectionScope";
-export { KeychainPersistence } from "./persistence/KeychainPersistence";
-export { LibSecretPersistence } from "./persistence/LibSecretPersistence";
-export { IPersistence } from "./persistence/IPersistence";
-export { CrossPlatformLockOptions } from "./lock/CrossPlatformLockOptions";
-export { PersistenceCreator } from "./persistence/PersistenceCreator";
-export { IPersistenceConfiguration } from "./persistence/IPersistenceConfiguration";
-export { Environment } from "./utils/Environment";
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export { PersistenceCachePlugin } from "./persistence/PersistenceCachePlugin";
+export { FilePersistence } from "./persistence/FilePersistence";
+export { FilePersistenceWithDataProtection } from "./persistence/FilePersistenceWithDataProtection";
+export { DataProtectionScope } from "./persistence/DataProtectionScope";
+export { KeychainPersistence } from "./persistence/KeychainPersistence";
+export { LibSecretPersistence } from "./persistence/LibSecretPersistence";
+export { IPersistence } from "./persistence/IPersistence";
+export { CrossPlatformLockOptions } from "./lock/CrossPlatformLockOptions";
+export { PersistenceCreator } from "./persistence/PersistenceCreator";
+export { IPersistenceConfiguration } from "./persistence/IPersistenceConfiguration";
+export { Environment } from "./utils/Environment";

package/src/lock/CrossPlatformLock.ts

@@ -1,89 +1,89 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { promises as fs } from "fs";
-import { pid } from "process";
-import { CrossPlatformLockOptions } from "./CrossPlatformLockOptions";
-import { Constants } from "../utils/Constants";
-import { PersistenceError } from "../error/PersistenceError";
-import { Logger } from "@azure/msal-common";
-
-/**
- * Cross-process lock that works on all platforms.
- */
-export class CrossPlatformLock {
-
-    private readonly lockFilePath: string;
-    private lockFileHandle: fs.FileHandle;
-    private readonly retryNumber: number;
-    private readonly retryDelay: number;
-
-    private logger: Logger;
-
-    constructor(lockFilePath: string, logger: Logger, lockOptions?: CrossPlatformLockOptions) {
-        this.lockFilePath = lockFilePath;
-        this.retryNumber = lockOptions ? lockOptions.retryNumber : 500;
-        this.retryDelay = lockOptions ? lockOptions.retryDelay : 100;
-        this.logger = logger;
-    }
-
-    /**
-     * Locks cache from read or writes by creating file with same path and name as
-     * cache file but with .lockfile extension. If another process has already created
-     * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
-     */
-    public async lock(): Promise<void> {
-        for (let tryCount = 0; tryCount < this.retryNumber; tryCount++) {
-            try {
-                this.logger.info(`Pid ${pid} trying to acquire lock`);
-                this.lockFileHandle = await fs.open(this.lockFilePath, "wx+");
-
-                this.logger.info(`Pid ${pid} acquired lock`);
-                await this.lockFileHandle.write(pid.toString());
-                return;
-            } catch (err) {
-                if (err.code === Constants.EEXIST_ERROR || err.code === Constants.EPERM_ERROR) {
-                    this.logger.info(err);
-                    await this.sleep(this.retryDelay);
-                } else {
-                    this.logger.error(`${pid} was not able to acquire lock. Ran into error: ${err.message}`);
-                    throw PersistenceError.createCrossPlatformLockError(err.message);
-                }
-            }
-        }
-        this.logger.error(`${pid} was not able to acquire lock. Exceeded amount of retries set in the options`);
-        throw PersistenceError.createCrossPlatformLockError(
-            "Not able to acquire lock. Exceeded amount of retries set in options");
-    }
-
-    /**
-     * unlocks cache file by deleting .lockfile.
-     */
-    public async unlock(): Promise<void> {
-        try {
-            if(this.lockFileHandle){
-                // if we have a file handle to the .lockfile, delete lock file
-                await fs.unlink(this.lockFilePath);
-                await this.lockFileHandle.close();
-                this.logger.info("lockfile deleted");
-            } else {
-                this.logger.warning("lockfile handle does not exist, so lockfile could not be deleted");
-            }
-        } catch (err) {
-            if (err.code === Constants.ENOENT_ERROR) {
-                this.logger.info("Tried to unlock but lockfile does not exist");
-            } else {
-                this.logger.error(`${pid} was not able to release lock. Ran into error: ${err.message}`);
-                throw PersistenceError.createCrossPlatformLockError(err.message);
-            }
-        }
-    }
-
-    private sleep(ms): Promise<void> {
-        return new Promise((resolve) => {
-            setTimeout(resolve, ms);
-        });
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "fs";
+import { pid } from "process";
+import { CrossPlatformLockOptions } from "./CrossPlatformLockOptions";
+import { Constants } from "../utils/Constants";
+import { PersistenceError } from "../error/PersistenceError";
+import { Logger } from "@azure/msal-common";
+
+/**
+ * Cross-process lock that works on all platforms.
+ */
+export class CrossPlatformLock {
+
+    private readonly lockFilePath: string;
+    private lockFileHandle: fs.FileHandle;
+    private readonly retryNumber: number;
+    private readonly retryDelay: number;
+
+    private logger: Logger;
+
+    constructor(lockFilePath: string, logger: Logger, lockOptions?: CrossPlatformLockOptions) {
+        this.lockFilePath = lockFilePath;
+        this.retryNumber = lockOptions ? lockOptions.retryNumber : 500;
+        this.retryDelay = lockOptions ? lockOptions.retryDelay : 100;
+        this.logger = logger;
+    }
+
+    /**
+     * Locks cache from read or writes by creating file with same path and name as
+     * cache file but with .lockfile extension. If another process has already created
+     * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
+     */
+    public async lock(): Promise<void> {
+        for (let tryCount = 0; tryCount < this.retryNumber; tryCount++) {
+            try {
+                this.logger.info(`Pid ${pid} trying to acquire lock`);
+                this.lockFileHandle = await fs.open(this.lockFilePath, "wx+");
+
+                this.logger.info(`Pid ${pid} acquired lock`);
+                await this.lockFileHandle.write(pid.toString());
+                return;
+            } catch (err) {
+                if (err.code === Constants.EEXIST_ERROR || err.code === Constants.EPERM_ERROR) {
+                    this.logger.info(err);
+                    await this.sleep(this.retryDelay);
+                } else {
+                    this.logger.error(`${pid} was not able to acquire lock. Ran into error: ${err.message}`);
+                    throw PersistenceError.createCrossPlatformLockError(err.message);
+                }
+            }
+        }
+        this.logger.error(`${pid} was not able to acquire lock. Exceeded amount of retries set in the options`);
+        throw PersistenceError.createCrossPlatformLockError(
+            "Not able to acquire lock. Exceeded amount of retries set in options");
+    }
+
+    /**
+     * unlocks cache file by deleting .lockfile.
+     */
+    public async unlock(): Promise<void> {
+        try {
+            if(this.lockFileHandle){
+                // if we have a file handle to the .lockfile, delete lock file
+                await fs.unlink(this.lockFilePath);
+                await this.lockFileHandle.close();
+                this.logger.info("lockfile deleted");
+            } else {
+                this.logger.warning("lockfile handle does not exist, so lockfile could not be deleted");
+            }
+        } catch (err) {
+            if (err.code === Constants.ENOENT_ERROR) {
+                this.logger.info("Tried to unlock but lockfile does not exist");
+            } else {
+                this.logger.error(`${pid} was not able to release lock. Ran into error: ${err.message}`);
+                throw PersistenceError.createCrossPlatformLockError(err.message);
+            }
+        }
+    }
+
+    private sleep(ms): Promise<void> {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+}

package/src/lock/CrossPlatformLockOptions.ts

@@ -1,15 +1,15 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Options for CrossPlatform lock.
- *
- * retryNumber: Numbers of times we should try to acquire a lock. Defaults to 500.
- * retryDelay: Time to wait before trying to retry a lock acquisition. Defaults to 100 ms.
- */
-export type CrossPlatformLockOptions = {
-    retryNumber: number;
-    retryDelay: number;
-};
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Options for CrossPlatform lock.
+ *
+ * retryNumber: Numbers of times we should try to acquire a lock. Defaults to 500.
+ * retryDelay: Time to wait before trying to retry a lock acquisition. Defaults to 100 ms.
+ */
+export type CrossPlatformLockOptions = {
+    retryNumber: number;
+    retryDelay: number;
+};

package/src/persistence/BasePersistence.ts

@@ -1,41 +1,41 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { PersistenceError } from "../error/PersistenceError";
-import { Constants } from "../utils/Constants";
-import { IPersistence } from "./IPersistence";
-
-export abstract class BasePersistence {
-    public abstract createForPersistenceValidation(): Promise<IPersistence>; 
-
-    public async verifyPersistence(): Promise<boolean> {
-        // We are using a different location for the test to avoid overriding the functional cache
-        const persistenceValidator = await this.createForPersistenceValidation();
-
-        try {
-            await persistenceValidator.save(Constants.PERSISTENCE_TEST_DATA);
-
-            const retrievedDummyData = await persistenceValidator.load();
-
-            if (!retrievedDummyData) {
-                throw PersistenceError.createCachePersistenceError(
-                    "Persistence check failed. Data was written but it could not be read. " +
-                    "Possible cause: on Linux, LibSecret is installed but D-Bus isn't running because it cannot be started over SSH."
-                );
-            }
-
-            if (retrievedDummyData !== Constants.PERSISTENCE_TEST_DATA) {
-                throw PersistenceError.createCachePersistenceError(
-                    `Persistence check failed. Data written ${Constants.PERSISTENCE_TEST_DATA} is different from data read ${retrievedDummyData}`
-                );
-            }
-            await persistenceValidator.delete();
-            return true;
-        } catch (e) {
-            throw PersistenceError.createCachePersistenceError(`Verifing persistence failed with the error: ${e}`);
-        }
-    }
-
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { PersistenceError } from "../error/PersistenceError";
+import { Constants } from "../utils/Constants";
+import { IPersistence } from "./IPersistence";
+
+export abstract class BasePersistence {
+    public abstract createForPersistenceValidation(): Promise<IPersistence>; 
+
+    public async verifyPersistence(): Promise<boolean> {
+        // We are using a different location for the test to avoid overriding the functional cache
+        const persistenceValidator = await this.createForPersistenceValidation();
+
+        try {
+            await persistenceValidator.save(Constants.PERSISTENCE_TEST_DATA);
+
+            const retrievedDummyData = await persistenceValidator.load();
+
+            if (!retrievedDummyData) {
+                throw PersistenceError.createCachePersistenceError(
+                    "Persistence check failed. Data was written but it could not be read. " +
+                    "Possible cause: on Linux, LibSecret is installed but D-Bus isn't running because it cannot be started over SSH."
+                );
+            }
+
+            if (retrievedDummyData !== Constants.PERSISTENCE_TEST_DATA) {
+                throw PersistenceError.createCachePersistenceError(
+                    `Persistence check failed. Data written ${Constants.PERSISTENCE_TEST_DATA} is different from data read ${retrievedDummyData}`
+                );
+            }
+            await persistenceValidator.delete();
+            return true;
+        } catch (e) {
+            throw PersistenceError.createCachePersistenceError(`Verifing persistence failed with the error: ${e}`);
+        }
+    }
+
+}

package/src/persistence/DataProtectionScope.ts

@@ -1,20 +1,20 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Specifies the scope of the data protection - either the current user or the local
- * machine.
- *
- * You do not need a key to protect or unprotect the data.
- * If you set the Scope to CurrentUser, only applications running on your credentials can
- * unprotect the data; however, that means that any application running on your credentials
- * can access the protected data. If you set the Scope to LocalMachine, any full-trust
- * application on the computer can unprotect, access, and modify the data.
- *
- */
-export enum DataProtectionScope {
-    CurrentUser = "CurrentUser",
-    LocalMachine = "LocalMachine",
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Specifies the scope of the data protection - either the current user or the local
+ * machine.
+ *
+ * You do not need a key to protect or unprotect the data.
+ * If you set the Scope to CurrentUser, only applications running on your credentials can
+ * unprotect the data; however, that means that any application running on your credentials
+ * can access the protected data. If you set the Scope to LocalMachine, any full-trust
+ * application on the computer can unprotect, access, and modify the data.
+ *
+ */
+export enum DataProtectionScope {
+    CurrentUser = "CurrentUser",
+    LocalMachine = "LocalMachine",
+}