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

package/src/persistence/KeychainPersistence.ts

@@ -1,86 +1,86 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { setPassword, getPassword, deletePassword } from "keytar";
-import { FilePersistence } from "./FilePersistence";
-import { IPersistence } from "./IPersistence";
-import { PersistenceError } from "../error/PersistenceError";
-import { Logger, LoggerOptions } from "@azure/msal-common";
-import { dirname } from "path";
-import { BasePersistence } from "./BasePersistence";
-
-/**
- * Uses reads and writes passwords to macOS keychain
- *
- * serviceName: Identifier used as key for whatever value is stored
- * accountName: Account under which password should be stored
- */
-export class KeychainPersistence extends BasePersistence implements IPersistence {
-
-    protected readonly serviceName;
-    protected readonly accountName;
-    private filePersistence: FilePersistence;
-
-    private constructor(serviceName: string, accountName: string) {
-        super();
-        this.serviceName = serviceName;
-        this.accountName = accountName;
-    }
-
-    public static async create(
-        fileLocation: string,
-        serviceName: string,
-        accountName: string,
-        loggerOptions?: LoggerOptions): Promise<KeychainPersistence> {
-
-        const persistence = new KeychainPersistence(serviceName, accountName);
-        persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
-        return persistence;
-    }
-
-    public async save(contents: string): Promise<void> {
-        try {
-            await setPassword(this.serviceName, this.accountName, contents);
-        } catch (err) {
-            throw PersistenceError.createKeychainPersistenceError(err.message);
-        }
-        // Write dummy data to update file mtime
-        await this.filePersistence.save("{}");
-    }
-
-    public async load(): Promise<string | null> {
-        try{
-            return await getPassword(this.serviceName, this.accountName);
-        } catch(err){
-            throw PersistenceError.createKeychainPersistenceError(err.message);
-        }
-    }
-
-    public async delete(): Promise<boolean> {
-        try {
-            await this.filePersistence.delete();
-            return await deletePassword(this.serviceName, this.accountName);
-        } catch (err) {
-            throw PersistenceError.createKeychainPersistenceError(err.message);
-        }
-    }
-
-    public async reloadNecessary(lastSync: number): Promise<boolean> {
-        return this.filePersistence.reloadNecessary(lastSync);
-    }
-
-    public getFilePath(): string {
-        return this.filePersistence.getFilePath();
-    }
-
-    public getLogger(): Logger {
-        return this.filePersistence.getLogger();
-    }
-   
-    public createForPersistenceValidation(): Promise<KeychainPersistence> {
-        const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
-        return KeychainPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { setPassword, getPassword, deletePassword } from "keytar";
+import { FilePersistence } from "./FilePersistence";
+import { IPersistence } from "./IPersistence";
+import { PersistenceError } from "../error/PersistenceError";
+import { Logger, LoggerOptions } from "@azure/msal-common";
+import { dirname } from "path";
+import { BasePersistence } from "./BasePersistence";
+
+/**
+ * Uses reads and writes passwords to macOS keychain
+ *
+ * serviceName: Identifier used as key for whatever value is stored
+ * accountName: Account under which password should be stored
+ */
+export class KeychainPersistence extends BasePersistence implements IPersistence {
+
+    protected readonly serviceName;
+    protected readonly accountName;
+    private filePersistence: FilePersistence;
+
+    private constructor(serviceName: string, accountName: string) {
+        super();
+        this.serviceName = serviceName;
+        this.accountName = accountName;
+    }
+
+    public static async create(
+        fileLocation: string,
+        serviceName: string,
+        accountName: string,
+        loggerOptions?: LoggerOptions): Promise<KeychainPersistence> {
+
+        const persistence = new KeychainPersistence(serviceName, accountName);
+        persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
+        return persistence;
+    }
+
+    public async save(contents: string): Promise<void> {
+        try {
+            await setPassword(this.serviceName, this.accountName, contents);
+        } catch (err) {
+            throw PersistenceError.createKeychainPersistenceError(err.message);
+        }
+        // Write dummy data to update file mtime
+        await this.filePersistence.save("{}");
+    }
+
+    public async load(): Promise<string | null> {
+        try{
+            return await getPassword(this.serviceName, this.accountName);
+        } catch(err){
+            throw PersistenceError.createKeychainPersistenceError(err.message);
+        }
+    }
+
+    public async delete(): Promise<boolean> {
+        try {
+            await this.filePersistence.delete();
+            return await deletePassword(this.serviceName, this.accountName);
+        } catch (err) {
+            throw PersistenceError.createKeychainPersistenceError(err.message);
+        }
+    }
+
+    public async reloadNecessary(lastSync: number): Promise<boolean> {
+        return this.filePersistence.reloadNecessary(lastSync);
+    }
+
+    public getFilePath(): string {
+        return this.filePersistence.getFilePath();
+    }
+
+    public getLogger(): Logger {
+        return this.filePersistence.getLogger();
+    }
+   
+    public createForPersistenceValidation(): Promise<KeychainPersistence> {
+        const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+        return KeychainPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
+    }
+}

package/src/persistence/LibSecretPersistence.ts

@@ -1,87 +1,87 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { setPassword, getPassword, deletePassword } from "keytar";
-import { FilePersistence } from "./FilePersistence";
-import { IPersistence } from "./IPersistence";
-import { PersistenceError } from "../error/PersistenceError";
-import { Logger, LoggerOptions } from "@azure/msal-common";
-import { dirname } from "path";
-import { BasePersistence } from "./BasePersistence";
-
-/**
- * Uses reads and writes passwords to Secret Service API/libsecret. Requires libsecret
- * to be installed.
- *
- * serviceName: Identifier used as key for whatever value is stored
- * accountName: Account under which password should be stored
- */
-export class LibSecretPersistence extends BasePersistence implements IPersistence {
-
-    protected readonly serviceName;
-    protected readonly accountName;
-    private filePersistence: FilePersistence;
-
-    private constructor(serviceName: string, accountName: string) {
-        super();
-        this.serviceName = serviceName;
-        this.accountName = accountName;
-    }
-
-    public static async create(
-        fileLocation: string,
-        serviceName: string,
-        accountName: string,
-        loggerOptions?: LoggerOptions): Promise<LibSecretPersistence> {
-
-        const persistence = new LibSecretPersistence(serviceName, accountName);
-        persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
-        return persistence;
-    }
-
-    public async save(contents: string): Promise<void> {
-        try {
-            await setPassword(this.serviceName, this.accountName, contents);
-        } catch (err) {
-            throw PersistenceError.createLibSecretError(err.message);
-        }
-        // Write dummy data to update file mtime
-        await this.filePersistence.save("{}");
-    }
-
-    public async load(): Promise<string | null> {
-        try {
-            return await getPassword(this.serviceName, this.accountName);
-        } catch (err) {
-            throw PersistenceError.createLibSecretError(err.message);
-        }
-    }
-
-    public async delete(): Promise<boolean> {
-        try {
-            await this.filePersistence.delete();
-            return await deletePassword(this.serviceName, this.accountName);
-        } catch (err) {
-            throw PersistenceError.createLibSecretError(err.message);
-        }
-    }
-
-    public async reloadNecessary(lastSync: number): Promise<boolean> {
-        return this.filePersistence.reloadNecessary(lastSync);
-    }
-
-    public getFilePath(): string {
-        return this.filePersistence.getFilePath();
-    }
-
-    public getLogger(): Logger {
-        return this.filePersistence.getLogger();
-    }
-      
-    public createForPersistenceValidation(): Promise<LibSecretPersistence> {
-        const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
-        return LibSecretPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { setPassword, getPassword, deletePassword } from "keytar";
+import { FilePersistence } from "./FilePersistence";
+import { IPersistence } from "./IPersistence";
+import { PersistenceError } from "../error/PersistenceError";
+import { Logger, LoggerOptions } from "@azure/msal-common";
+import { dirname } from "path";
+import { BasePersistence } from "./BasePersistence";
+
+/**
+ * Uses reads and writes passwords to Secret Service API/libsecret. Requires libsecret
+ * to be installed.
+ *
+ * serviceName: Identifier used as key for whatever value is stored
+ * accountName: Account under which password should be stored
+ */
+export class LibSecretPersistence extends BasePersistence implements IPersistence {
+
+    protected readonly serviceName;
+    protected readonly accountName;
+    private filePersistence: FilePersistence;
+
+    private constructor(serviceName: string, accountName: string) {
+        super();
+        this.serviceName = serviceName;
+        this.accountName = accountName;
+    }
+
+    public static async create(
+        fileLocation: string,
+        serviceName: string,
+        accountName: string,
+        loggerOptions?: LoggerOptions): Promise<LibSecretPersistence> {
+
+        const persistence = new LibSecretPersistence(serviceName, accountName);
+        persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
+        return persistence;
+    }
+
+    public async save(contents: string): Promise<void> {
+        try {
+            await setPassword(this.serviceName, this.accountName, contents);
+        } catch (err) {
+            throw PersistenceError.createLibSecretError(err.message);
+        }
+        // Write dummy data to update file mtime
+        await this.filePersistence.save("{}");
+    }
+
+    public async load(): Promise<string | null> {
+        try {
+            return await getPassword(this.serviceName, this.accountName);
+        } catch (err) {
+            throw PersistenceError.createLibSecretError(err.message);
+        }
+    }
+
+    public async delete(): Promise<boolean> {
+        try {
+            await this.filePersistence.delete();
+            return await deletePassword(this.serviceName, this.accountName);
+        } catch (err) {
+            throw PersistenceError.createLibSecretError(err.message);
+        }
+    }
+
+    public async reloadNecessary(lastSync: number): Promise<boolean> {
+        return this.filePersistence.reloadNecessary(lastSync);
+    }
+
+    public getFilePath(): string {
+        return this.filePersistence.getFilePath();
+    }
+
+    public getLogger(): Logger {
+        return this.filePersistence.getLogger();
+    }
+      
+    public createForPersistenceValidation(): Promise<LibSecretPersistence> {
+        const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+        return LibSecretPersistence.create(testCacheFileLocation, "persistenceValidationServiceName", "persistencValidationAccountName");
+    }
+}

package/src/persistence/PersistenceCachePlugin.ts

@@ -1,106 +1,106 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IPersistence } from "./IPersistence";
-import { CrossPlatformLock } from "../lock/CrossPlatformLock";
-import { CrossPlatformLockOptions } from "../lock/CrossPlatformLockOptions";
-import { pid } from "process";
-import { TokenCacheContext, ICachePlugin, Logger } from "@azure/msal-common";
-
-/**
- * MSAL cache plugin which enables callers to write the MSAL cache to disk on Windows,
- * macOs, and Linux.
- *
- * - Persistence can be one of:
- * - FilePersistence: Writes and reads from an unencrypted file. Can be used on Windows,
- * macOs, or Linux.
- * - FilePersistenceWithDataProtection: Used on Windows, writes and reads from file encrypted
- * with windows dpapi-addon.
- * - KeychainPersistence: Used on macOs, writes and reads from keychain.
- * - LibSecretPersistence: Used on linux, writes and reads from secret service API. Requires
- * libsecret be installed.
- */
-export class PersistenceCachePlugin implements ICachePlugin {
-
-    public persistence: IPersistence;
-    public lastSync: number;
-    public currentCache: string;
-    public lockFilePath: string;
-
-    private crossPlatformLock: CrossPlatformLock;
-
-    private logger: Logger;
-
-    constructor(persistence: IPersistence, lockOptions?: CrossPlatformLockOptions) {
-        this.persistence = persistence;
-
-        // initialize logger
-        this.logger = persistence.getLogger();
-
-        // create file lock
-        this.lockFilePath = `${this.persistence.getFilePath()}.lockfile`;
-        this.crossPlatformLock = new CrossPlatformLock(this.lockFilePath, this.logger, lockOptions);
-
-        // initialize default values
-        this.lastSync = 0;
-        this.currentCache = null;
-    }
-
-    /**
-     * Reads from storage and saves an in-memory copy. If persistence has not been updated
-     * since last time data was read, in memory copy is used.
-     *
-     * If cacheContext.cacheHasChanged === true, then file lock is created and not deleted until
-     * afterCacheAccess() is called, to prevent the cache file from changing in between
-     * beforeCacheAccess() and afterCacheAccess().
-     */
-    public async beforeCacheAccess(cacheContext: TokenCacheContext): Promise<void> {
-        this.logger.info("Executing before cache access");
-        const reloadNecessary = await this.persistence.reloadNecessary(this.lastSync);
-        if (!reloadNecessary && this.currentCache !== null) {
-            if (cacheContext.cacheHasChanged) {
-                this.logger.verbose("Cache context has changed");
-                await this.crossPlatformLock.lock();
-            }
-            return;
-        }
-        try {
-            this.logger.info(`Reload necessary. Last sync time: ${this.lastSync}`);
-            await this.crossPlatformLock.lock();
-
-            this.currentCache = await this.persistence.load();
-            this.lastSync = new Date().getTime();
-            cacheContext.tokenCache.deserialize(this.currentCache);
-
-            this.logger.info(`Last sync time updated to: ${this.lastSync}`);
-        } finally {
-            if (!cacheContext.cacheHasChanged) {
-                await this.crossPlatformLock.unlock();
-                this.logger.info(`Pid ${pid} released lock`);
-            } else {
-                this.logger.info(`Pid ${pid} beforeCacheAccess did not release lock`);
-            }
-        }
-    }
-
-    /**
-     * Writes to storage if MSAL in memory copy of cache has been changed.
-     */
-    public async afterCacheAccess(cacheContext: TokenCacheContext): Promise<void> {
-        this.logger.info("Executing after cache access");
-        try {
-            if (cacheContext.cacheHasChanged) {
-                this.logger.info("Msal in-memory cache has changed. Writing changes to persistence");
-                this.currentCache = cacheContext.tokenCache.serialize();
-                await this.persistence.save(this.currentCache);
-            } else {
-                this.logger.info("Msal in-memory cache has not changed. Did not write to persistence");
-            }
-        } finally {
-            await this.crossPlatformLock.unlock();
-            this.logger.info(`Pid ${pid} afterCacheAccess released lock`);
-        }
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IPersistence } from "./IPersistence";
+import { CrossPlatformLock } from "../lock/CrossPlatformLock";
+import { CrossPlatformLockOptions } from "../lock/CrossPlatformLockOptions";
+import { pid } from "process";
+import { TokenCacheContext, ICachePlugin, Logger } from "@azure/msal-common";
+
+/**
+ * MSAL cache plugin which enables callers to write the MSAL cache to disk on Windows,
+ * macOs, and Linux.
+ *
+ * - Persistence can be one of:
+ * - FilePersistence: Writes and reads from an unencrypted file. Can be used on Windows,
+ * macOs, or Linux.
+ * - FilePersistenceWithDataProtection: Used on Windows, writes and reads from file encrypted
+ * with windows dpapi-addon.
+ * - KeychainPersistence: Used on macOs, writes and reads from keychain.
+ * - LibSecretPersistence: Used on linux, writes and reads from secret service API. Requires
+ * libsecret be installed.
+ */
+export class PersistenceCachePlugin implements ICachePlugin {
+
+    public persistence: IPersistence;
+    public lastSync: number;
+    public currentCache: string;
+    public lockFilePath: string;
+
+    private crossPlatformLock: CrossPlatformLock;
+
+    private logger: Logger;
+
+    constructor(persistence: IPersistence, lockOptions?: CrossPlatformLockOptions) {
+        this.persistence = persistence;
+
+        // initialize logger
+        this.logger = persistence.getLogger();
+
+        // create file lock
+        this.lockFilePath = `${this.persistence.getFilePath()}.lockfile`;
+        this.crossPlatformLock = new CrossPlatformLock(this.lockFilePath, this.logger, lockOptions);
+
+        // initialize default values
+        this.lastSync = 0;
+        this.currentCache = null;
+    }
+
+    /**
+     * Reads from storage and saves an in-memory copy. If persistence has not been updated
+     * since last time data was read, in memory copy is used.
+     *
+     * If cacheContext.cacheHasChanged === true, then file lock is created and not deleted until
+     * afterCacheAccess() is called, to prevent the cache file from changing in between
+     * beforeCacheAccess() and afterCacheAccess().
+     */
+    public async beforeCacheAccess(cacheContext: TokenCacheContext): Promise<void> {
+        this.logger.info("Executing before cache access");
+        const reloadNecessary = await this.persistence.reloadNecessary(this.lastSync);
+        if (!reloadNecessary && this.currentCache !== null) {
+            if (cacheContext.cacheHasChanged) {
+                this.logger.verbose("Cache context has changed");
+                await this.crossPlatformLock.lock();
+            }
+            return;
+        }
+        try {
+            this.logger.info(`Reload necessary. Last sync time: ${this.lastSync}`);
+            await this.crossPlatformLock.lock();
+
+            this.currentCache = await this.persistence.load();
+            this.lastSync = new Date().getTime();
+            cacheContext.tokenCache.deserialize(this.currentCache);
+
+            this.logger.info(`Last sync time updated to: ${this.lastSync}`);
+        } finally {
+            if (!cacheContext.cacheHasChanged) {
+                await this.crossPlatformLock.unlock();
+                this.logger.info(`Pid ${pid} released lock`);
+            } else {
+                this.logger.info(`Pid ${pid} beforeCacheAccess did not release lock`);
+            }
+        }
+    }
+
+    /**
+     * Writes to storage if MSAL in memory copy of cache has been changed.
+     */
+    public async afterCacheAccess(cacheContext: TokenCacheContext): Promise<void> {
+        this.logger.info("Executing after cache access");
+        try {
+            if (cacheContext.cacheHasChanged) {
+                this.logger.info("Msal in-memory cache has changed. Writing changes to persistence");
+                this.currentCache = cacheContext.tokenCache.serialize();
+                await this.persistence.save(this.currentCache);
+            } else {
+                this.logger.info("Msal in-memory cache has not changed. Did not write to persistence");
+            }
+        } finally {
+            await this.crossPlatformLock.unlock();
+            this.logger.info(`Pid ${pid} afterCacheAccess released lock`);
+        }
+    }
+}