Merge branch 'main' into yanzh/support-both-map-object

Eskibear · web-flow · commit 35adc57045af · 2024-02-26T10:50:39.000+08:00
diff --git a/src/AzureAppConfigurationImpl.ts b/src/AzureAppConfigurationImpl.ts
@@ -232,7 +232,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {
     /**
      * Refresh the configuration store.
      */
-    public async refresh(): Promise<void> {
+    async refresh(): Promise<void> {
         if (!this.#refreshEnabled) {
             throw new Error("Refresh is not enabled.");
         }
diff --git a/src/JsonKeyValueAdapter.ts b/src/JsonKeyValueAdapter.ts
@@ -4,24 +4,23 @@
 import { ConfigurationSetting, secretReferenceContentType } from "@azure/app-configuration";
 import { IKeyValueAdapter } from "./IKeyValueAdapter";
 
-
 export class JsonKeyValueAdapter implements IKeyValueAdapter {
-    private static readonly ExcludedJsonContentTypes: string[] = [
+    static readonly #ExcludedJsonContentTypes: string[] = [
         secretReferenceContentType
         // TODO: exclude application/vnd.microsoft.appconfig.ff+json after feature management is supported
     ];
 
-    public canProcess(setting: ConfigurationSetting): boolean {
+    canProcess(setting: ConfigurationSetting): boolean {
         if (!setting.contentType) {
             return false;
         }
-        if (JsonKeyValueAdapter.ExcludedJsonContentTypes.includes(setting.contentType)) {
+        if (JsonKeyValueAdapter.#ExcludedJsonContentTypes.includes(setting.contentType)) {
             return false;
         }
         return isJsonContentType(setting.contentType);
     }
 
-    public async processKeyValue(setting: ConfigurationSetting): Promise<[string, unknown]> {
+    async processKeyValue(setting: ConfigurationSetting): Promise<[string, unknown]> {
         let parsedValue: unknown;
         if (setting.value !== undefined) {
             try {
diff --git a/src/common/disposable.ts b/src/common/disposable.ts
@@ -2,14 +2,17 @@
 // Licensed under the MIT license.
 
 export class Disposable {
-    private disposed = false;
-    constructor(private callOnDispose: () => any) { }
+    #disposed = false;
+    #callOnDispose: () => any;
+
+    constructor(callOnDispose: () => any) {
+        this.#callOnDispose = callOnDispose;
+    }
 
     dispose() {
-        if (!this.disposed) {
-            this.callOnDispose();
+        if (!this.#disposed) {
+            this.#callOnDispose();
         }
-        this.disposed = true;
+        this.#disposed = true;
     }
-
 }
diff --git a/src/keyvault/AzureKeyVaultKeyValueAdapter.ts b/src/keyvault/AzureKeyVaultKeyValueAdapter.ts
@@ -10,19 +10,20 @@ export class AzureKeyVaultKeyValueAdapter implements IKeyValueAdapter {
     /**
      * Map vault hostname to corresponding secret client.
     */
-    private secretClients: Map<string, SecretClient>;
+    #secretClients: Map<string, SecretClient>;
+    #keyVaultOptions: KeyVaultOptions | undefined;
 
-    constructor(
-        private keyVaultOptions: KeyVaultOptions | undefined
-    ) { }
+    constructor(keyVaultOptions: KeyVaultOptions | undefined) {
+        this.#keyVaultOptions = keyVaultOptions;
+    }
 
-    public canProcess(setting: ConfigurationSetting): boolean {
+    canProcess(setting: ConfigurationSetting): boolean {
         return isSecretReference(setting);
     }
 
-    public async processKeyValue(setting: ConfigurationSetting): Promise<[string, unknown]> {
+    async processKeyValue(setting: ConfigurationSetting): Promise<[string, unknown]> {
         // TODO: cache results to save requests.
-        if (!this.keyVaultOptions) {
+        if (!this.#keyVaultOptions) {
             throw new Error("Configure keyVaultOptions to resolve Key Vault Reference(s).");
         }
 
@@ -31,37 +32,37 @@ export class AzureKeyVaultKeyValueAdapter implements IKeyValueAdapter {
             parseSecretReference(setting).value.secretId
         );
 
-        const client = this.getSecretClient(new URL(vaultUrl));
+        const client = this.#getSecretClient(new URL(vaultUrl));
         if (client) {
             // TODO: what if error occurs when reading a key vault value? Now it breaks the whole load.
             const secret = await client.getSecret(secretName, { version });
             return [setting.key, secret.value];
         }
 
-        if (this.keyVaultOptions.secretResolver) {
-            return [setting.key, await this.keyVaultOptions.secretResolver(new URL(sourceId))];
+        if (this.#keyVaultOptions.secretResolver) {
+            return [setting.key, await this.#keyVaultOptions.secretResolver(new URL(sourceId))];
         }
 
         throw new Error("No key vault credential or secret resolver callback configured, and no matching secret client could be found.");
     }
 
-    private getSecretClient(vaultUrl: URL): SecretClient | undefined {
-        if (this.secretClients === undefined) {
-            this.secretClients = new Map();
-            for (const c of this.keyVaultOptions?.secretClients ?? []) {
-                this.secretClients.set(getHost(c.vaultUrl), c);
+    #getSecretClient(vaultUrl: URL): SecretClient | undefined {
+        if (this.#secretClients === undefined) {
+            this.#secretClients = new Map();
+            for (const c of this.#keyVaultOptions?.secretClients ?? []) {
+                this.#secretClients.set(getHost(c.vaultUrl), c);
             }
         }
 
         let client: SecretClient | undefined;
-        client = this.secretClients.get(vaultUrl.host);
+        client = this.#secretClients.get(vaultUrl.host);
         if (client !== undefined) {
             return client;
         }
 
-        if (this.keyVaultOptions?.credential) {
-            client = new SecretClient(vaultUrl.toString(), this.keyVaultOptions.credential);
-            this.secretClients.set(vaultUrl.host, client);
+        if (this.#keyVaultOptions?.credential) {
+            client = new SecretClient(vaultUrl.toString(), this.#keyVaultOptions.credential);
+            this.#secretClients.set(vaultUrl.host, client);
             return client;
         }
 
diff --git a/src/load.ts b/src/load.ts
@@ -48,7 +48,7 @@ export async function load(
                 endpoint = new URL(endpoint);
             } catch (error) {
                 if (error.code === "ERR_INVALID_URL") {
-                    throw new Error("Invalid Endpoint URL.", { cause: error });
+                    throw new Error("Invalid endpoint URL.", { cause: error });
                 } else {
                     throw error;
                 }
diff --git a/src/refresh/RefreshTimer.ts b/src/refresh/RefreshTimer.ts
@@ -22,52 +22,55 @@ const MaxSafeExponential = 30; // Used to avoid overflow. bitwise operations in
 const JitterRatio = 0.25;
 
 export class RefreshTimer {
-    private _minBackoff: number = MinimumBackoffInMs;
-    private _maxBackoff: number = MaximumBackoffInMs;
-    private _failedAttempts: number = 0;
-    private _backoffEnd: number; // Timestamp
+    #minBackoff: number = MinimumBackoffInMs;
+    #maxBackoff: number = MaximumBackoffInMs;
+    #failedAttempts: number = 0;
+    #backoffEnd: number; // Timestamp
+    #interval: number;
+
     constructor(
-        private _interval: number
+        interval: number
     ) {
-        if (this._interval <= 0) {
-            throw new Error(`Refresh interval must be greater than 0. Given: ${this._interval}`);
+        if (interval <= 0) {
+            throw new Error(`Refresh interval must be greater than 0. Given: ${this.#interval}`);
         }
 
-        this._backoffEnd = Date.now() + this._interval;
+        this.#interval = interval;
+        this.#backoffEnd = Date.now() + this.#interval;
     }
 
-    public canRefresh(): boolean {
-        return Date.now() >= this._backoffEnd;
+    canRefresh(): boolean {
+        return Date.now() >= this.#backoffEnd;
     }
 
-    public backoff(): void {
-        this._failedAttempts += 1;
-        this._backoffEnd = Date.now() + this._calculateBackoffTime();
+    backoff(): void {
+        this.#failedAttempts += 1;
+        this.#backoffEnd = Date.now() + this.#calculateBackoffTime();
     }
 
-    public reset(): void {
-        this._failedAttempts = 0;
-        this._backoffEnd = Date.now() + this._interval;
+    reset(): void {
+        this.#failedAttempts = 0;
+        this.#backoffEnd = Date.now() + this.#interval;
     }
 
-    private _calculateBackoffTime(): number {
+    #calculateBackoffTime(): number {
         let minBackoffMs: number;
         let maxBackoffMs: number;
-        if (this._interval <= this._minBackoff) {
-            return this._interval;
+        if (this.#interval <= this.#minBackoff) {
+            return this.#interval;
         }
 
         // _minBackoff <= _interval
-        if (this._interval <= this._maxBackoff) {
-            minBackoffMs = this._minBackoff;
-            maxBackoffMs = this._interval;
+        if (this.#interval <= this.#maxBackoff) {
+            minBackoffMs = this.#minBackoff;
+            maxBackoffMs = this.#interval;
         } else {
-            minBackoffMs = this._minBackoff;
-            maxBackoffMs = this._maxBackoff;
+            minBackoffMs = this.#minBackoff;
+            maxBackoffMs = this.#maxBackoff;
         }
 
         // exponential: minBackoffMs * 2^(failedAttempts-1)
-        const exponential = Math.min(this._failedAttempts - 1, MaxSafeExponential);
+        const exponential = Math.min(this.#failedAttempts - 1, MaxSafeExponential);
         let calculatedBackoffMs = minBackoffMs * (1 << exponential);
         if (calculatedBackoffMs > maxBackoffMs) {
             calculatedBackoffMs = maxBackoffMs;
diff --git a/test/keyvault.test.ts b/test/keyvault.test.ts
@@ -27,6 +27,8 @@ function mockNewlyCreatedKeyVaultSecretClients() {
     mockSecretClientGetSecret(mockedData.map(([_key, secretUri, value]) => [secretUri, value]));
 }
 describe("key vault reference", function () {
+    this.timeout(10000);
+
     beforeEach(() => {
         mockAppConfigurationClient();
         mockNewlyCreatedKeyVaultSecretClients();
@@ -37,7 +39,7 @@ describe("key vault reference", function () {
     });
 
     it("require key vault options to resolve reference", async () => {
-        expect(load(createMockedConnectionString())).eventually.rejected;
+        return expect(load(createMockedConnectionString())).eventually.rejectedWith("Configure keyVaultOptions to resolve Key Vault Reference(s).");
     });
 
     it("should resolve key vault reference with credential", async () => {
@@ -93,7 +95,7 @@ describe("key vault reference", function () {
                 ]
             }
         });
-        expect(loadKeyVaultPromise).eventually.rejected;
+        return expect(loadKeyVaultPromise).eventually.rejectedWith("No key vault credential or secret resolver callback configured, and no matching secret client could be found.");
     });
 
     it("should fallback to use default credential when corresponding secret client not provided", async () => {
diff --git a/test/load.test.ts b/test/load.test.ts
@@ -41,6 +41,8 @@ const mockedKVs = [{
 }].map(createMockedKeyValue);
 
 describe("load", function () {
+    this.timeout(10000);
+
     before(() => {
         mockAppConfigurationClientListConfigurationSettings(mockedKVs);
     });
@@ -75,12 +77,12 @@ describe("load", function () {
     });
 
     it("should throw error given invalid connection string", async () => {
-        expect(load("invalid-connection-string")).eventually.rejected;
+        return expect(load("invalid-connection-string")).eventually.rejectedWith("Invalid connection string.");
     });
 
     it("should throw error given invalid endpoint URL", async () => {
         const credential = createMockedTokenCredential();
-        expect(load("invalid-endpoint-url", credential)).eventually.rejected;
+        return expect(load("invalid-endpoint-url", credential)).eventually.rejectedWith("Invalid endpoint URL.");
     });
 
     it("should trim key prefix if applicable", async () => {
@@ -119,23 +121,26 @@ describe("load", function () {
         expect(settings.get("KeyForEmptyValue")).eq("");
     });
 
-    it("should not support * or , in label filters", async () => {
+    it("should not support * in label filters", async () => {
         const connectionString = createMockedConnectionString();
         const loadWithWildcardLabelFilter = load(connectionString, {
             selectors: [{
                 keyFilter: "app.*",
                 labelFilter: "*"
             }]
         });
-        expect(loadWithWildcardLabelFilter).to.eventually.rejected;
+        return expect(loadWithWildcardLabelFilter).to.eventually.rejectedWith("The characters '*' and ',' are not supported in label filters.");
+    });
 
+    it("should not support , in label filters", async () => {
+        const connectionString = createMockedConnectionString();
         const loadWithMultipleLabelFilter = load(connectionString, {
             selectors: [{
                 keyFilter: "app.*",
                 labelFilter: "labelA,labelB"
             }]
         });
-        expect(loadWithMultipleLabelFilter).to.eventually.rejected;
+        return expect(loadWithMultipleLabelFilter).to.eventually.rejectedWith("The characters '*' and ',' are not supported in label filters.");
     });
 
     it("should override config settings with same key but different label", async () => {

Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ export class AzureAppConfigurationImpl implements AzureAppConfiguration {`
`232`	`232`	`/**`
`233`	`233`	`* Refresh the configuration store.`
`234`	`234`	`*/`
`235`		`- public async refresh(): Promise<void> {`
	`235`	`+ async refresh(): Promise<void> {`
`236`	`236`	`if (!this.#refreshEnabled) {`
`237`	`237`	`throw new Error("Refresh is not enabled.");`
`238`	`238`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ export async function load(`
`48`	`48`	`endpoint = new URL(endpoint);`
`49`	`49`	`} catch (error) {`
`50`	`50`	`if (error.code === "ERR_INVALID_URL") {`
`51`		`- throw new Error("Invalid Endpoint URL.", { cause: error });`
	`51`	`+ throw new Error("Invalid endpoint URL.", { cause: error });`
`52`	`52`	`} else {`
`53`	`53`	`throw error;`
`54`	`54`	`}`