@ms-cloudpack/remote-cache 0.7.9 → 0.8.1

package/dist/{getListOfBlobs-TYZM4XYI.js → getListOfBlobs-2GKCJGDO.js}

@@ -6,15 +6,15 @@ const __filename = topLevelUrl.fileURLToPath(import.meta.url);
 const __dirname = topLevelPath.dirname(__filename);
 import {
   createBlobStorageUrl
-} from "./chunk-IVPGYNQL.js";
+} from "./chunk-GFDVXVVH.js";
 import {
   require_dist
-} from "./chunk-VCWIWY5Y.js";
-import "./chunk-TXSHKS6T.js";
+} from "./chunk-FW2AO4WO.js";
+import "./chunk-D7DHZQ7L.js";
 import {
   __name,
   __toESM
-} from "./chunk-B4GP6UPK.js";
+} from "./chunk-LRFMBF43.js";
 
 // src/getListOfBlobs.ts
 var import_storage_blob = __toESM(require_dist(), 1);

package/dist/index.js

@@ -7,7 +7,7 @@ const __dirname = topLevelPath.dirname(__filename);
 import {
   __name,
   require_commonjs
-} from "./chunk-B4GP6UPK.js";
+} from "./chunk-LRFMBF43.js";
 
 // src/registerAzureLogger.ts
 import EventEmitter from "events";
@@ -84,10 +84,10 @@ var RetryDecorator = _RetryDecorator;
 // src/retry/blockListIsInvalidRetryPolicy.ts
 var blockListIsInvalidRetryPolicy = {
   maxRetries: 1,
-  handle: (error) => {
+  handle: /* @__PURE__ */ __name((error) => {
     return error instanceof Error && error.message.indexOf("The specified block list is invalid.") > -1;
-  },
-  wait: () => 0
+  }, "handle"),
+  wait: /* @__PURE__ */ __name(() => 0, "wait")
 };
 
 // src/createRemoteCacheClient.ts
@@ -96,10 +96,10 @@ async function createRemoteCacheClient(params) {
   const azureLogEventHandler = registerAzureLogger();
   const { context, options } = params;
   const { container, loginMethod, storageAccount, cachePath, tenantId } = options;
-  const { getCredential } = await import("./getCredential-QZKOLRT5.js");
-  const { AzureRemoteCacheClient } = await import("./AzureRemoteCacheClient-LMRNY2C6.js");
-  const { ReporterDecorator } = await import("./ReporterDecorator-JLGERQ2U.js");
-  const { getListOfBlobs } = await import("./getListOfBlobs-TYZM4XYI.js");
+  const { getCredential } = await import("./getCredential-W6MRP3D2.js");
+  const { AzureRemoteCacheClient } = await import("./AzureRemoteCacheClient-YFWJLZNA.js");
+  const { ReporterDecorator } = await import("./ReporterDecorator-5LUAHYKK.js");
+  const { getListOfBlobs } = await import("./getListOfBlobs-2GKCJGDO.js");
   const credential = await getCredential(
     { loginMethod, cachePath, tenantId },
     { ...context, azureLogger: azureLogEventHandler }
@@ -115,7 +115,7 @@ async function createRemoteCacheClient(params) {
       retryManager: new RetryManager([blockListIsInvalidRetryPolicy]),
       cacheClient: new InMemoryDecorator({
         cacheClient: new AzureRemoteCacheClient(remoteCacheClientOptions),
-        getList: () => Promise.resolve(listOfBlobs)
+        getList: /* @__PURE__ */ __name(() => Promise.resolve(listOfBlobs), "getList")
       })
     }),
     context

package/lib/authentication/forks/identity-cache-persistence/cachePersistencePlugin.d.ts

@@ -0,0 +1,34 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/identity-cache-persistence` package.
+ * https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity-cache-persistence/src/index.ts
+ */
+import type { IdentityPlugin } from '@azure/identity';
+/**
+ * A plugin that provides persistent token caching for `@azure/identity`
+ * credentials. The plugin API is compatible with `@azure/identity` versions
+ * 2.0.0 and later. Load this plugin using the `useIdentityPlugin`
+ * function, imported from `@azure/identity`.
+ *
+ * In order to enable this functionality, you must also pass
+ * `tokenCachePersistenceOptions` to your credential constructors with an
+ * `enabled` property set to true.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { useIdentityPlugin, DeviceCodeCredential } from "@azure/identity";
+ * import { cachePersistencePlugin } from "@azure/identity-cache-persistence";
+ *
+ * // Load the plugin
+ * useIdentityPlugin(cachePersistencePlugin);
+ *
+ * const credential = new DeviceCodeCredential({
+ *   tokenCachePersistenceOptions: {
+ *     enabled: true
+ *   }
+ * });
+ * ```
+ */
+export declare const cachePersistencePlugin: IdentityPlugin;
+//# sourceMappingURL=cachePersistencePlugin.d.ts.map

package/lib/authentication/forks/identity-cache-persistence/platforms.d.ts

@@ -0,0 +1,50 @@
+import type { TokenCachePersistenceOptions } from '@azure/identity';
+import type { IPersistence } from '../msal-node-extensions/persistence/IPersistence.js';
+/**
+ * Dictionary of values that we use as default as we discover, pick and enable the persistence layer.
+ * @internal
+ */
+export declare const defaultMsalValues: {
+    tokenCache: {
+        name: string;
+        directory: string;
+    };
+    keyRing: {
+        label: string;
+        schema: string;
+        collection: string;
+        attributes: {
+            MsalClientID: string;
+            'Microsoft.Developer.IdentityService': string;
+        };
+        service: string;
+        account: string;
+    };
+    keyChain: {
+        service: string;
+        account: string;
+    };
+};
+/**
+ * Options that are used by the underlying MSAL cache provider.
+ * @internal
+ */
+export type MsalPersistenceOptions = Omit<TokenCachePersistenceOptions, 'enabled'>;
+/**
+ * A function that returns a persistent token cache instance.
+ * @internal
+ */
+type MsalPersistenceFactory = (options?: MsalPersistenceOptions) => Promise<IPersistence>;
+/**
+ * Set of the platforms we attempt to deliver persistence on.
+ *
+ * - On Windows we use DPAPI.
+ * - On OSX (Darwin) and Linux, we try to use the system's Keyring, otherwise if the property `unsafeAllowUnencryptedStorage` is set to true, we use an unencrypted file.
+ *
+ * Other platforms _are not supported_ at this time.
+ *
+ * @internal
+ */
+export declare const msalPersistencePlatforms: Partial<Record<NodeJS.Platform, MsalPersistenceFactory>>;
+export {};
+//# sourceMappingURL=platforms.d.ts.map

package/lib/authentication/forks/identity-cache-persistence/provider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/identity-cache-persistence` package.
+ * https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity-cache-persistence/src/provider.ts
+ */
+import type { MsalPersistenceOptions } from './platforms.js';
+import type { ICachePlugin as CachePlugin } from '@azure/msal-node';
+import type { IPersistence } from '../msal-node-extensions/persistence/IPersistence.js';
+/**
+ * This is used to gain access to the underlying Persistence instance, which we use for testing
+ *
+ * @returns a raw persistence instance
+ * @internal
+ */
+export declare function createPersistence(options: MsalPersistenceOptions): Promise<IPersistence>;
+export declare function createPersistenceCachePlugin(options?: MsalPersistenceOptions): Promise<CachePlugin>;
+//# sourceMappingURL=provider.d.ts.map

package/lib/authentication/forks/msal-node-extensions/error/PersistenceError.d.ts

@@ -0,0 +1,37 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/error/PersistenceError.ts
+ */
+/**
+ * Error thrown when trying to write MSAL cache to persistence.
+ */
+export declare class PersistenceError extends Error {
+    errorCode: string;
+    errorMessage: string;
+    constructor(errorCode: string, errorMessage: string);
+    /**
+     * Error thrown when trying to access the file system.
+     */
+    static createFileSystemError(errorCode: string, errorMessage: string): PersistenceError;
+    /**
+     * Error thrown when trying to encrypt or decrypt data using DPAPI on Windows.
+     */
+    static createFilePersistenceWithDPAPIError(errorMessage: string): PersistenceError;
+    /**
+     * Error thrown when using the cross platform lock.
+     */
+    static createCrossPlatformLockError(errorMessage: string): PersistenceError;
+    /**
+     * Error thrown when trying to write, load, or delete data from NapiRsKeyRingPersistence.
+     */
+    static createNapiRsKeyRingPersistenceError(errorMessage: string): PersistenceError;
+    /**
+     * Throw cache persistence error
+     *
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createCachePersistenceError(errorMessage: string): PersistenceError;
+}
+//# sourceMappingURL=PersistenceError.d.ts.map

package/lib/authentication/forks/msal-node-extensions/lock/CrossPlatformLock.d.ts

@@ -0,0 +1,25 @@
+import type { CrossPlatformLockOptions } from './CrossPlatformLockOptions.js';
+import type { Logger } from '@azure/msal-common';
+/**
+ * Cross-process lock that works on all platforms.
+ */
+export declare class CrossPlatformLock {
+    private readonly lockFilePath;
+    private lockFileHandle;
+    private readonly retryNumber;
+    private readonly retryDelay;
+    private logger;
+    constructor(lockFilePath: string, logger: Logger, lockOptions?: CrossPlatformLockOptions);
+    /**
+     * 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
+     */
+    lock(): Promise<void>;
+    /**
+     * unlocks cache file by deleting .lockfile.
+     */
+    unlock(): Promise<void>;
+    private sleep;
+}
+//# sourceMappingURL=CrossPlatformLock.d.ts.map

package/lib/authentication/forks/msal-node-extensions/lock/CrossPlatformLockOptions.d.ts

@@ -0,0 +1,16 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/lock/CrossPlatformLockOptions.ts
+ */
+/**
+ * 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;
+};
+//# sourceMappingURL=CrossPlatformLockOptions.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/BasePersistence.d.ts

@@ -0,0 +1,6 @@
+import type { IPersistence } from './IPersistence.js';
+export declare abstract class BasePersistence {
+    abstract createForPersistenceValidation(): Promise<IPersistence>;
+    verifyPersistence(): Promise<boolean>;
+}
+//# sourceMappingURL=BasePersistence.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/FilePersistence.d.ts

@@ -0,0 +1,31 @@
+import type { IPersistence } from './IPersistence.js';
+import type { LoggerOptions } from '@azure/msal-common';
+import { Logger } from '@azure/msal-common';
+import { BasePersistence } from './BasePersistence.js';
+/**
+ * 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 declare class FilePersistence extends BasePersistence implements IPersistence {
+    private filePath;
+    private logger;
+    private constructor();
+    static create(fileLocation: string, loggerOptions?: LoggerOptions): Promise<FilePersistence>;
+    save(contents: string): Promise<void>;
+    saveBuffer(contents: Uint8Array): Promise<void>;
+    load(): Promise<string | null>;
+    loadBuffer(): Promise<Uint8Array>;
+    delete(): Promise<boolean>;
+    getFilePath(): string;
+    reloadNecessary(lastSync: number): Promise<boolean>;
+    getLogger(): Logger;
+    createForPersistenceValidation(): Promise<FilePersistence>;
+    private static createDefaultLoggerOptions;
+    private timeLastModified;
+    private createCacheFile;
+    private createFileDirectory;
+}
+//# sourceMappingURL=FilePersistence.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/FilePersistenceWithDataProtection.d.ts

@@ -0,0 +1,30 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/persistence/FilePersistenceWithDataProtection.ts
+ */
+import type { IPersistence } from './IPersistence.js';
+import { type DataProtectionScope } from 'node-dpapi-prebuilt';
+import type { Logger, LoggerOptions } from '@azure/msal-common';
+import { BasePersistence } from './BasePersistence.js';
+/**
+ * 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 declare class FilePersistenceWithDataProtection extends BasePersistence implements IPersistence {
+    private filePersistence;
+    private scope;
+    private optionalEntropy;
+    private constructor();
+    static create(fileLocation: string, scope: DataProtectionScope, optionalEntropy?: string, loggerOptions?: LoggerOptions): Promise<FilePersistenceWithDataProtection>;
+    save(contents: string): Promise<void>;
+    load(): Promise<string | null>;
+    delete(): Promise<boolean>;
+    reloadNecessary(lastSync: number): Promise<boolean>;
+    getFilePath(): string;
+    getLogger(): Logger;
+    createForPersistenceValidation(): Promise<FilePersistenceWithDataProtection>;
+}
+//# sourceMappingURL=FilePersistenceWithDataProtection.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/IPersistence.d.ts

@@ -0,0 +1,17 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/persistence/IPersistence.ts
+ */
+import type { Logger } from '@azure/msal-common';
+export interface IPersistence {
+    save(contents: string): Promise<void>;
+    load(): Promise<string | null>;
+    delete(): Promise<boolean>;
+    reloadNecessary(lastSync: number): Promise<boolean>;
+    getFilePath(): string;
+    getLogger(): Logger;
+    verifyPersistence(): Promise<boolean>;
+    createForPersistenceValidation(): Promise<IPersistence>;
+}
+//# sourceMappingURL=IPersistence.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/IPersistenceConfiguration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/persistence/IPersistenceConfiguration.ts
+ */
+import type { LoggerOptions } from '@azure/msal-common';
+import type { DataProtectionScope } from 'node-dpapi-prebuilt';
+export interface IPersistenceConfiguration {
+    cachePath?: string;
+    dataProtectionScope?: DataProtectionScope;
+    serviceName?: string;
+    accountName?: string;
+    usePlaintextFileOnLinux?: boolean;
+    loggerOptions?: LoggerOptions;
+}
+//# sourceMappingURL=IPersistenceConfiguration.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/NapiRsKeyRingPersistence.d.ts

@@ -0,0 +1,19 @@
+import type { Logger, LoggerOptions } from '@azure/msal-common';
+import { BasePersistence } from './BasePersistence.js';
+import type { IPersistence } from './IPersistence.js';
+export declare class NapiRsKeyRingPersistance extends BasePersistence implements IPersistence {
+    readonly service: string;
+    readonly account: string;
+    private readonly entry;
+    private readonly filePersistence;
+    private constructor();
+    static create(fileLocation: string, serviceName: string, accountName: string, loggerOptions?: LoggerOptions): Promise<NapiRsKeyRingPersistance>;
+    save(contents: string): Promise<void>;
+    load(): Promise<string | null>;
+    delete(): Promise<boolean>;
+    reloadNecessary(lastSync: number): Promise<boolean>;
+    getFilePath(): string;
+    getLogger(): Logger;
+    createForPersistenceValidation(): Promise<IPersistence>;
+}
+//# sourceMappingURL=NapiRsKeyRingPersistence.d.ts.map

package/lib/authentication/forks/msal-node-extensions/persistence/PersistenceCachePlugin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/persistence/PersistenceCachePlugin.ts
+ */
+import type { IPersistence } from './IPersistence.js';
+import type { CrossPlatformLockOptions } from '../lock/CrossPlatformLockOptions.js';
+import type { TokenCacheContext, ICachePlugin } from '@azure/msal-common';
+/**
+ * MSAL cache plugin which enables callers to write the MSAL cache to disk on Windows,
+ * macOs, and Linux.
+ */
+export declare class PersistenceCachePlugin implements ICachePlugin {
+    persistence: IPersistence;
+    lastSync: number;
+    currentCache: string | null;
+    lockFilePath: string;
+    private crossPlatformLock;
+    private logger;
+    constructor(persistence: IPersistence, lockOptions?: CrossPlatformLockOptions);
+    /**
+     * 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().
+     */
+    beforeCacheAccess(cacheContext: TokenCacheContext): Promise<void>;
+    /**
+     * Writes to storage if MSAL in memory copy of cache has been changed.
+     */
+    afterCacheAccess(cacheContext: TokenCacheContext): Promise<void>;
+}
+//# sourceMappingURL=PersistenceCachePlugin.d.ts.map

package/lib/authentication/forks/msal-node-extensions/utils/Constants.d.ts

@@ -0,0 +1,44 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/utils/Constants.ts
+ */
+export declare const Constants: {
+    /**
+     * An existing file was the target of an operation that required that the target not exist
+     */
+    EEXIST_ERROR: string;
+    /**
+     * No such file or directory: Commonly raised by fs operations to indicate that a component
+     * of the specified pathname does not exist. No entity (file or directory) could be found
+     * by the given path
+     */
+    ENOENT_ERROR: string;
+    /**
+     * Operation not permitted. An attempt was made to perform an operation that requires
+     * elevated privileges.
+     */
+    EPERM_ERROR: string;
+    /**
+     * Default service name for using MSAL Keytar
+     */
+    DEFAULT_SERVICE_NAME: string;
+    /**
+     * Test data used to verify underlying persistence mechanism
+     */
+    PERSISTENCE_TEST_DATA: string;
+    DEFAULT_CACHE_FILE_NAME: string;
+};
+export declare const Platform: {
+    readonly WINDOWS: "win32";
+    readonly LINUX: "linux";
+    readonly MACOS: "darwin";
+};
+export type Platform = (typeof Platform)[keyof typeof Platform];
+export declare const ErrorCodes: {
+    readonly INTERATION_REQUIRED_ERROR_CODE: "interaction_required";
+    readonly SERVER_UNAVAILABLE: "server_unavailable";
+    readonly UNKNOWN: "unknown_error";
+};
+export type ErrorCodes = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+//# sourceMappingURL=Constants.d.ts.map

package/lib/authentication/forks/msal-node-extensions/utils/TypeGuards.d.ts

@@ -0,0 +1,10 @@
+/**
+ * FORK NOTE:
+ * This file has been copied over from the `@azure/msal-node-extensions` package.
+ * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/extensions/msal-node-extensions/src/utils/TypeGuards.ts
+ */
+/**
+ * Returns whether or not the given object is a Node.js error
+ */
+export declare const isNodeError: (error: unknown) => error is NodeJS.ErrnoException;
+//# sourceMappingURL=TypeGuards.d.ts.map

package/lib/authentication/getCredential.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { type TokenCredential } from '@azure/identity';
 import type { LoginMethod } from '../types/LoginMethod.js';
 import type { TaskReporter } from '@ms-cloudpack/task-reporter';

package/lib/registerAzureLogger.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import EventEmitter from 'events';
 /**
  * Registers a custom logger for the Azure SDK that emits events for some specific log messages.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ms-cloudpack/remote-cache",
-  "version": "0.7.9",
+  "version": "0.8.1",
   "description": "Manages syncing the local Cloudpack cached assets to/from a remote storage service.",
   "license": "MIT",
   "type": "module",
@@ -27,15 +27,17 @@
     "lib/**/*.d.ts"
   ],
   "dependencies": {
-    "@azure/msal-node-extensions": "^1.0.10",
     "@ms-cloudpack/retry": "^0.1.2",
     "@ms-cloudpack/task-reporter": "^0.14.1",
-    "@ms-cloudpack/telemetry": "^0.5.3"
+    "@ms-cloudpack/telemetry": "^0.6.1",
+    "@napi-rs/keyring": "^1.0.0",
+    "node-dpapi-prebuilt": "^1.0.3"
   },
   "devDependencies": {
     "@azure/identity": "^4.2.1",
-    "@azure/identity-cache-persistence": "^1.1.0",
     "@azure/logger": "^1.0.0",
+    "@azure/msal-common": "14.12.0",
+    "@azure/msal-node": "^2.9.2",
     "@azure/storage-blob": "^12.17.0",
     "@ms-cloudpack/eslint-plugin-internal": "*",
     "@ms-cloudpack/scripts": "*",