@azure/msal-node-extensions 1.0.0-alpha.3 → 1.0.0-alpha.30

package/src/persistence/FilePersistence.ts

@@ -1,134 +1,140 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { promises as fs } from "fs";
-import { dirname } from "path";
-import { IPersistence } from "./IPersistence";
-import { Constants } from "../utils/Constants";
-import { PersistenceError } from "../error/PersistenceError";
-import { Logger, LoggerOptions, LogLevel } from "@azure/msal-common";
-
-/**
- * Reads and writes data to file specified by file location. File contents are not
- * encrypted.
- *
- * If file or directory has not been created, it FilePersistence.create() will create
- * file and any directories in the path recursively.
- */
-export class FilePersistence implements IPersistence {
-
-    private filePath: string;
-    private logger: Logger;
-
-    public static async create(fileLocation: string, loggerOptions?: LoggerOptions): Promise<FilePersistence> {
-        const filePersistence = new FilePersistence();
-        filePersistence.filePath = fileLocation;
-        filePersistence.logger = new Logger(loggerOptions || FilePersistence.createDefaultLoggerOptions());
-        await filePersistence.createCacheFile();
-        return filePersistence;
-    }
-
-    public async save(contents: string): Promise<void> {
-        try {
-            await fs.writeFile(this.getFilePath(), contents, "utf-8");
-        } catch (err) {
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    public async saveBuffer(contents: Uint8Array): Promise<void> {
-        try {
-            await fs.writeFile(this.getFilePath(), contents);
-        } catch (err) {
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    public async load(): Promise<string> {
-        try {
-            return await fs.readFile(this.getFilePath(), "utf-8");
-        } catch (err) {
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    public async loadBuffer(): Promise<Uint8Array> {
-        try {
-            return await fs.readFile(this.getFilePath());
-        } catch (err) {
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    public async delete(): Promise<boolean> {
-        try {
-            await fs.unlink(this.getFilePath());
-            return true;
-        } catch (err) {
-            if (err.code == Constants.ENOENT_ERROR) {
-                // file does not exist, so it was not deleted
-                this.logger.warning("Cache file does not exist, so it could not be deleted");
-                return false;
-            }
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    public getFilePath(): string {
-        return this.filePath;
-    }
-
-    public async reloadNecessary(lastSync: number): Promise<boolean> {
-        return lastSync < await this.timeLastModified();
-    }
-
-    public getLogger(): Logger {
-        return this.logger;
-    }
-
-    private static createDefaultLoggerOptions(): LoggerOptions {
-        return {
-            loggerCallback: () => {
-                // allow users to not set loggerCallback
-            },
-            piiLoggingEnabled: false,
-            logLevel: LogLevel.Info
-        };
-    }
-
-    private async timeLastModified(): Promise<number> {
-        try {
-            const stats = await fs.stat(this.filePath);
-            return stats.mtime.getTime();
-        } catch (err) {
-            if (err.code == Constants.ENOENT_ERROR) {
-                // file does not exist, so it's never been modified
-                this.logger.verbose("Cache file does not exist");
-                return 0;
-            }
-            throw PersistenceError.createFileSystemError(err.code, err.message);
-        }
-    }
-
-    private async createCacheFile(): Promise<void> {
-        await this.createFileDirectory();
-        // File is created only if it does not exist
-        const fileHandle = await fs.open(this.filePath, "a");
-        await fileHandle.close();
-        this.logger.info(`File created at ${this.filePath}`);
-    }
-
-    private async createFileDirectory(): Promise<void> {
-        try {
-            await fs.mkdir(dirname(this.filePath), {recursive: true});
-        } catch (err) {
-            if (err.code == Constants.EEXIST_ERROR) {
-                this.logger.info(`Directory ${dirname(this.filePath)}  already exists`);
-            } else {
-                throw PersistenceError.createFileSystemError(err.code, err.message);
-            }
-        }
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "fs";
+import { dirname } from "path";
+import { IPersistence } from "./IPersistence";
+import { Constants } from "../utils/Constants";
+import { PersistenceError } from "../error/PersistenceError";
+import { Logger, LoggerOptions, LogLevel } from "@azure/msal-common";
+import { BasePersistence } from "./BasePersistence";
+
+/**
+ * Reads and writes data to file specified by file location. File contents are not
+ * encrypted.
+ *
+ * If file or directory has not been created, it FilePersistence.create() will create
+ * file and any directories in the path recursively.
+ */
+export class FilePersistence extends BasePersistence implements IPersistence {
+
+    private filePath: string;
+    private logger: Logger;
+
+    public static async create(fileLocation: string, loggerOptions?: LoggerOptions): Promise<FilePersistence> {
+        const filePersistence = new FilePersistence();
+        filePersistence.filePath = fileLocation;
+        filePersistence.logger = new Logger(loggerOptions || FilePersistence.createDefaultLoggerOptions());
+        await filePersistence.createCacheFile();
+        return filePersistence;
+    }
+
+    public async save(contents: string): Promise<void> {
+        try {
+            await fs.writeFile(this.getFilePath(), contents, "utf-8");
+        } catch (err) {
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public async saveBuffer(contents: Uint8Array): Promise<void> {
+        try {
+            await fs.writeFile(this.getFilePath(), contents);
+        } catch (err) {
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public async load(): Promise<string | null> {
+        try {
+            return await fs.readFile(this.getFilePath(), "utf-8");
+        } catch (err) {
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public async loadBuffer(): Promise<Uint8Array> {
+        try {
+            return await fs.readFile(this.getFilePath());
+        } catch (err) {
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public async delete(): Promise<boolean> {
+        try {
+            await fs.unlink(this.getFilePath());
+            return true;
+        } catch (err) {
+            if (err.code === Constants.ENOENT_ERROR) {
+                // file does not exist, so it was not deleted
+                this.logger.warning("Cache file does not exist, so it could not be deleted");
+                return false;
+            }
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    public getFilePath(): string {
+        return this.filePath;
+    }
+
+    public async reloadNecessary(lastSync: number): Promise<boolean> {
+        return lastSync < await this.timeLastModified();
+    }
+
+    public getLogger(): Logger {
+        return this.logger;
+    }
+
+    public createForPersistenceValidation(): Promise<FilePersistence> {
+        const testCacheFileLocation = `${dirname(this.filePath)}/test.cache`;
+        return FilePersistence.create(testCacheFileLocation);
+    }
+
+    private static createDefaultLoggerOptions(): LoggerOptions {
+        return {
+            loggerCallback: () => {
+                // allow users to not set loggerCallback
+            },
+            piiLoggingEnabled: false,
+            logLevel: LogLevel.Info
+        };
+    }
+
+    private async timeLastModified(): Promise<number> {
+        try {
+            const stats = await fs.stat(this.filePath);
+            return stats.mtime.getTime();
+        } catch (err) {
+            if (err.code === Constants.ENOENT_ERROR) {
+                // file does not exist, so it's never been modified
+                this.logger.verbose("Cache file does not exist");
+                return 0;
+            }
+            throw PersistenceError.createFileSystemError(err.code, err.message);
+        }
+    }
+
+    private async createCacheFile(): Promise<void> {
+        await this.createFileDirectory();
+        // File is created only if it does not exist
+        const fileHandle = await fs.open(this.filePath, "a");
+        await fileHandle.close();
+        this.logger.info(`File created at ${this.filePath}`);
+    }
+
+    private async createFileDirectory(): Promise<void> {
+        try {
+            await fs.mkdir(dirname(this.filePath), {recursive: true});
+        } catch (err) {
+            if (err.code === Constants.EEXIST_ERROR) {
+                this.logger.info(`Directory ${dirname(this.filePath)}  already exists`);
+            } else {
+                throw PersistenceError.createFileSystemError(err.code, err.message);
+            }
+        }
+    }
+}

package/src/persistence/FilePersistenceWithDataProtection.ts

@@ -1,84 +1,92 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IPersistence } from "./IPersistence";
-import { FilePersistence } from "./FilePersistence";
-import { PersistenceError } from "../error/PersistenceError";
-import { Dpapi } from "../dpapi-addon/Dpapi";
-import { DataProtectionScope } from "./DataProtectionScope";
-import { Logger, LoggerOptions } from "@azure/msal-common";
-
-/**
- * Uses CryptProtectData and CryptUnprotectData on Windows to encrypt and decrypt file contents.
- *
- * scope: Scope of the data protection. Either local user or the current machine
- * optionalEntropy: Password or other additional entropy used to encrypt the data
- */
-export class FilePersistenceWithDataProtection implements IPersistence {
-
-    private filePersistence: FilePersistence;
-    private scope: DataProtectionScope;
-    private optionalEntropy: Uint8Array;
-
-    private constructor(scope: DataProtectionScope, optionalEntropy?: string) {
-        this.scope = scope;
-        this.optionalEntropy = optionalEntropy ? Buffer.from(optionalEntropy, "utf-8") : null;
-    }
-
-    public static async create(
-        fileLocation: string,
-        scope: DataProtectionScope,
-        optionalEntropy?: string,
-        loggerOptions?: LoggerOptions): Promise<FilePersistenceWithDataProtection> {
-
-        const persistence = new FilePersistenceWithDataProtection(scope, optionalEntropy);
-        persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
-        return persistence;
-    }
-
-    public async save(contents: string): Promise<void> {
-        try {
-            const encryptedContents = Dpapi.protectData(
-                Buffer.from(contents, "utf-8"),
-                this.optionalEntropy,
-                this.scope.toString());
-            await this.filePersistence.saveBuffer(encryptedContents);
-        } catch (err) {
-            throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
-        }
-    }
-
-    public async load(): Promise<string | null> {
-        try {
-            const encryptedContents = await this.filePersistence.loadBuffer();
-            if (typeof encryptedContents === "undefined" || !encryptedContents || 0 === encryptedContents.length) {
-                this.filePersistence.getLogger().info("Encrypted contents loaded from file were null or empty");
-                return null;
-            }
-            return Dpapi.unprotectData(
-                encryptedContents,
-                this.optionalEntropy,
-                this.scope.toString()).toString();
-        } catch (err) {
-            throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
-        }
-    }
-
-    public async delete(): Promise<boolean> {
-        return this.filePersistence.delete();
-    }
-
-    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();
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { IPersistence } from "./IPersistence";
+import { FilePersistence } from "./FilePersistence";
+import { PersistenceError } from "../error/PersistenceError";
+import { Dpapi } from "../Dpapi";
+import { DataProtectionScope } from "./DataProtectionScope";
+import { Logger, LoggerOptions } from "@azure/msal-common";
+import { dirname } from "path";
+import { BasePersistence } from "./BasePersistence";
+
+/**
+ * Uses CryptProtectData and CryptUnprotectData on Windows to encrypt and decrypt file contents.
+ *
+ * scope: Scope of the data protection. Either local user or the current machine
+ * optionalEntropy: Password or other additional entropy used to encrypt the data
+ */
+export class FilePersistenceWithDataProtection extends BasePersistence implements IPersistence {
+
+    private filePersistence: FilePersistence;
+    private scope: DataProtectionScope;
+    private optionalEntropy: Uint8Array;
+
+    private constructor(scope: DataProtectionScope, optionalEntropy?: string) {
+        super();
+        this.scope = scope;
+        this.optionalEntropy = optionalEntropy ? Buffer.from(optionalEntropy, "utf-8") : null;
+    }
+
+    public static async create(
+        fileLocation: string,
+        scope: DataProtectionScope,
+        optionalEntropy?: string,
+        loggerOptions?: LoggerOptions): Promise<FilePersistenceWithDataProtection> {
+
+        const persistence = new FilePersistenceWithDataProtection(scope, optionalEntropy);
+        persistence.filePersistence = await FilePersistence.create(fileLocation, loggerOptions);
+        return persistence;
+    }
+
+    public async save(contents: string): Promise<void> {
+        try {
+            const encryptedContents = Dpapi.protectData(
+                Buffer.from(contents, "utf-8"),
+                this.optionalEntropy,
+                this.scope.toString());
+            await this.filePersistence.saveBuffer(encryptedContents);
+        } catch (err) {
+            throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
+        }
+    }
+
+    public async load(): Promise<string | null> {
+        try {
+            const encryptedContents = await this.filePersistence.loadBuffer();
+            if (typeof encryptedContents === "undefined" || !encryptedContents || 0 === encryptedContents.length) {
+                this.filePersistence.getLogger().info("Encrypted contents loaded from file were null or empty");
+                return null;
+            }
+            return Dpapi.unprotectData(
+                encryptedContents,
+                this.optionalEntropy,
+                this.scope.toString()).toString();
+        } catch (err) {
+            throw PersistenceError.createFilePersistenceWithDPAPIError(err.message);
+        }
+    }
+
+    public async delete(): Promise<boolean> {
+        return this.filePersistence.delete();
+    }
+
+    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<FilePersistenceWithDataProtection> {
+        const testCacheFileLocation = `${dirname(this.filePersistence.getFilePath())}/test.cache`;
+        return FilePersistenceWithDataProtection.create(testCacheFileLocation, DataProtectionScope.CurrentUser);
+    }
+}

package/src/persistence/IPersistence.ts

@@ -7,9 +7,11 @@ import { Logger } from "@azure/msal-common";
 
 export interface IPersistence {
     save(contents: string): Promise<void>;
-    load(): Promise<string>;
+    load(): Promise<string | null>;
     delete(): Promise<boolean>;
     reloadNecessary(lastSync: number): Promise<boolean>;
     getFilePath(): string;
-    getLogger(): Logger
+    getLogger(): Logger;
+    verifyPersistence(): Promise<boolean>;
+    createForPersistenceValidation(): Promise<IPersistence>;
 }

package/src/persistence/IPersistenceConfiguration.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { LoggerOptions } from "@azure/msal-common";
+
+import { DataProtectionScope } from "./DataProtectionScope";
+
+export interface IPersistenceConfiguration {
+    cachePath?: string,
+    dataProtectionScope?: DataProtectionScope,
+    serviceName?: string,
+    accountName?: string,
+    usePlaintextFileOnLinux?: boolean,
+    loggerOptions?: LoggerOptions;
+}