@codingame/monaco-vscode-authentication-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/services/authentication/browser/authenticationQueryService.js

@@ -30,16 +30,18 @@ class AccountExtensionQuery extends BaseQuery {
         return this.queryService.authenticationAccessService.isAccessAllowed(this.providerId, this.accountName, this.extensionId);
     }
     setAccessAllowed(allowed, extensionName) {
-        this.queryService.authenticationAccessService.updateAllowedExtensions(this.providerId, this.accountName, [{ id: this.extensionId, name: extensionName || this.extensionId, allowed }]);
+        this.queryService.authenticationAccessService.updateAllowedExtensions(this.providerId, this.accountName, [{
+            id: this.extensionId,
+            name: extensionName || this.extensionId,
+            allowed
+        }]);
     }
     addUsage(scopes, extensionName) {
         this.queryService.authenticationUsageService.addAccountUsage(this.providerId, this.accountName, scopes, this.extensionId, extensionName);
     }
     getUsage() {
         const allUsages = this.queryService.authenticationUsageService.readAccountUsages(this.providerId, this.accountName);
-        return ( allUsages
-            .filter(usage => usage.extensionId === ExtensionIdentifier.toKey(this.extensionId))
-            .map(usage => ({
+        return ( allUsages.filter(usage => usage.extensionId === ExtensionIdentifier.toKey(this.extensionId)).map(usage => ({
             extensionId: usage.extensionId,
             extensionName: usage.extensionName,
             scopes: usage.scopes || [],
@@ -51,11 +53,20 @@ class AccountExtensionQuery extends BaseQuery {
         const filteredUsages = allUsages.filter(usage => usage.extensionId !== this.extensionId);
         this.queryService.authenticationUsageService.removeAccountUsage(this.providerId, this.accountName);
         for (const usage of filteredUsages) {
-            this.queryService.authenticationUsageService.addAccountUsage(this.providerId, this.accountName, usage.scopes || [], usage.extensionId, usage.extensionName);
+            this.queryService.authenticationUsageService.addAccountUsage(
+                this.providerId,
+                this.accountName,
+                usage.scopes || [],
+                usage.extensionId,
+                usage.extensionName
+            );
         }
     }
     setAsPreferred() {
-        this.queryService.authenticationExtensionsService.updateAccountPreference(this.extensionId, this.providerId, { label: this.accountName, id: this.accountName });
+        this.queryService.authenticationExtensionsService.updateAccountPreference(this.extensionId, this.providerId, {
+            label: this.accountName,
+            id: this.accountName
+        });
     }
     isPreferred() {
         const preferredAccount = this.queryService.authenticationExtensionsService.getAccountPreference(this.extensionId, this.providerId);
@@ -77,16 +88,18 @@ class AccountMcpServerQuery extends BaseQuery {
         return this.queryService.authenticationMcpAccessService.isAccessAllowed(this.providerId, this.accountName, this.mcpServerId);
     }
     setAccessAllowed(allowed, mcpServerName) {
-        this.queryService.authenticationMcpAccessService.updateAllowedMcpServers(this.providerId, this.accountName, [{ id: this.mcpServerId, name: mcpServerName || this.mcpServerId, allowed }]);
+        this.queryService.authenticationMcpAccessService.updateAllowedMcpServers(this.providerId, this.accountName, [{
+            id: this.mcpServerId,
+            name: mcpServerName || this.mcpServerId,
+            allowed
+        }]);
     }
     addUsage(scopes, mcpServerName) {
         this.queryService.authenticationMcpUsageService.addAccountUsage(this.providerId, this.accountName, scopes, this.mcpServerId, mcpServerName);
     }
     getUsage() {
         const allUsages = this.queryService.authenticationMcpUsageService.readAccountUsages(this.providerId, this.accountName);
-        return ( allUsages
-            .filter(usage => usage.mcpServerId === this.mcpServerId)
-            .map(usage => ({
+        return ( allUsages.filter(usage => usage.mcpServerId === this.mcpServerId).map(usage => ({
             mcpServerId: usage.mcpServerId,
             mcpServerName: usage.mcpServerName,
             scopes: usage.scopes || [],
@@ -98,11 +111,20 @@ class AccountMcpServerQuery extends BaseQuery {
         const filteredUsages = allUsages.filter(usage => usage.mcpServerId !== this.mcpServerId);
         this.queryService.authenticationMcpUsageService.removeAccountUsage(this.providerId, this.accountName);
         for (const usage of filteredUsages) {
-            this.queryService.authenticationMcpUsageService.addAccountUsage(this.providerId, this.accountName, usage.scopes || [], usage.mcpServerId, usage.mcpServerName);
+            this.queryService.authenticationMcpUsageService.addAccountUsage(
+                this.providerId,
+                this.accountName,
+                usage.scopes || [],
+                usage.mcpServerId,
+                usage.mcpServerName
+            );
         }
     }
     setAsPreferred() {
-        this.queryService.authenticationMcpService.updateAccountPreference(this.mcpServerId, this.providerId, { label: this.accountName, id: this.accountName });
+        this.queryService.authenticationMcpService.updateAccountPreference(this.mcpServerId, this.providerId, {
+            label: this.accountName,
+            id: this.accountName
+        });
     }
     isPreferred() {
         const preferredAccount = this.queryService.authenticationMcpService.getAccountPreference(this.mcpServerId, this.providerId);
@@ -122,9 +144,7 @@ class AccountExtensionsQuery extends BaseQuery {
     getAllowedExtensions() {
         const allowedExtensions = this.queryService.authenticationAccessService.readAllowedExtensions(this.providerId, this.accountName);
         const usages = this.queryService.authenticationUsageService.readAccountUsages(this.providerId, this.accountName);
-        return ( allowedExtensions
-            .filter(ext => ext.allowed !== false)
-            .map(ext => {
+        return ( allowedExtensions.filter(ext => ext.allowed !== false).map(ext => {
             const extensionUsages = usages.filter(usage => usage.extensionId === ext.id);
             const lastUsed = extensionUsages.length > 0 ? Math.max(...( extensionUsages.map(u => u.lastUsed))) : undefined;
             const extensionQuery = ( new AccountExtensionQuery(this.providerId, this.accountName, ext.id, this.queryService));
@@ -139,11 +159,19 @@ class AccountExtensionsQuery extends BaseQuery {
         }));
     }
     allowAccess(extensionIds) {
-        const extensionsToAllow = ( extensionIds.map(id => ({ id, name: id, allowed: true })));
+        const extensionsToAllow = ( extensionIds.map(id => ({
+            id,
+            name: id,
+            allowed: true
+        })));
         this.queryService.authenticationAccessService.updateAllowedExtensions(this.providerId, this.accountName, extensionsToAllow);
     }
     removeAccess(extensionIds) {
-        const extensionsToRemove = ( extensionIds.map(id => ({ id, name: id, allowed: false })));
+        const extensionsToRemove = ( extensionIds.map(id => ({
+            id,
+            name: id,
+            allowed: false
+        })));
         this.queryService.authenticationAccessService.updateAllowedExtensions(this.providerId, this.accountName, extensionsToRemove);
     }
     forEach(callback) {
@@ -164,15 +192,22 @@ class AccountMcpServersQuery extends BaseQuery {
         this.accountName = accountName;
     }
     getAllowedMcpServers() {
-        return this.queryService.authenticationMcpAccessService.readAllowedMcpServers(this.providerId, this.accountName)
-            .filter(server => server.allowed !== false);
+        return this.queryService.authenticationMcpAccessService.readAllowedMcpServers(this.providerId, this.accountName).filter(server => server.allowed !== false);
     }
     allowAccess(mcpServerIds) {
-        const mcpServersToAllow = ( mcpServerIds.map(id => ({ id, name: id, allowed: true })));
+        const mcpServersToAllow = ( mcpServerIds.map(id => ({
+            id,
+            name: id,
+            allowed: true
+        })));
         this.queryService.authenticationMcpAccessService.updateAllowedMcpServers(this.providerId, this.accountName, mcpServersToAllow);
     }
     removeAccess(mcpServerIds) {
-        const mcpServersToRemove = ( mcpServerIds.map(id => ({ id, name: id, allowed: false })));
+        const mcpServersToRemove = ( mcpServerIds.map(id => ({
+            id,
+            name: id,
+            allowed: false
+        })));
         this.queryService.authenticationMcpAccessService.updateAllowedMcpServers(this.providerId, this.accountName, mcpServersToRemove);
     }
     forEach(callback) {
@@ -247,11 +282,11 @@ class AccountEntitiesQuery extends BaseQuery {
     forEach(callback) {
         const extensionsQuery = ( new AccountExtensionsQuery(this.providerId, this.accountName, this.queryService));
         extensionsQuery.forEach(extensionQuery => {
-            callback(extensionQuery.extensionId, 'extension');
+            callback(extensionQuery.extensionId, "extension");
         });
         const mcpServersQuery = ( new AccountMcpServersQuery(this.providerId, this.accountName, this.queryService));
         mcpServersQuery.forEach(mcpServerQuery => {
-            callback(mcpServerQuery.mcpServerId, 'mcpServer');
+            callback(mcpServerQuery.mcpServerId, "mcpServer");
         });
     }
 }
@@ -318,8 +353,7 @@ class ProviderMcpServerQuery extends BaseQuery {
                 }
             }
             return lastUsedAccount;
-        }
-        catch {
+        } catch {
             return undefined;
         }
     }
@@ -343,8 +377,7 @@ class ProviderMcpServerQuery extends BaseQuery {
                 }
             }
             return usedAccounts;
-        }
-        catch {
+        } catch {
             return [];
         }
     }
@@ -381,17 +414,17 @@ class ProviderQuery extends BaseQuery {
                     }
                 }
             }
-        }
-        catch {
-        }
-        return { extensions, mcpServers };
+        } catch {}
+        return {
+            extensions,
+            mcpServers
+        };
     }
     async getAccountNames() {
         try {
             const accounts = await this.queryService.authenticationService.getAccounts(this.providerId);
             return ( accounts.map(account => account.label));
-        }
-        catch {
+        } catch {
             return [];
         }
     }
@@ -409,15 +442,21 @@ class ProviderQuery extends BaseQuery {
                 const usageCount = allUsages.length;
                 const lastUsed = Math.max(...( allUsages.map(u => u.lastUsed)), 0);
                 if (usageCount > 0) {
-                    recentActivity.push({ accountName: account.label, lastUsed, usageCount });
+                    recentActivity.push({
+                        accountName: account.label,
+                        lastUsed,
+                        usageCount
+                    });
                 }
             }
             recentActivity.sort((a, b) => b.lastUsed - a.lastUsed);
             totalSessions = recentActivity.reduce((sum, activity) => sum + activity.usageCount, 0);
-        }
-        catch {
-        }
-        return { totalSessions, totalAccounts, recentActivity };
+        } catch {}
+        return {
+            totalSessions,
+            totalAccounts,
+            recentActivity
+        };
     }
     async forEachAccount(callback) {
         try {
@@ -426,9 +465,7 @@ class ProviderQuery extends BaseQuery {
                 const accountQuery = ( new AccountQuery(this.providerId, account.label, this.queryService));
                 callback(accountQuery);
             }
-        }
-        catch {
-        }
+        } catch {}
     }
 }
 class ExtensionQuery {
@@ -452,9 +489,7 @@ class ExtensionQuery {
                 if (hasAccess) {
                     providersWithAccess.push(providerId);
                 }
-            }
-            catch {
-            }
+            } catch {}
         }
         return providersWithAccess;
     }
@@ -497,9 +532,7 @@ class McpServerQuery {
                 if (hasAccess) {
                     providersWithAccess.push(providerId);
                 }
-            }
-            catch {
-            }
+            } catch {}
         }
         return providersWithAccess;
     }
@@ -522,7 +555,16 @@ class McpServerQuery {
     }
 }
 let AuthenticationQueryService = class AuthenticationQueryService extends Disposable {
-    constructor(authenticationService, authenticationUsageService, authenticationMcpUsageService, authenticationAccessService, authenticationMcpAccessService, authenticationExtensionsService, authenticationMcpService, logService) {
+    constructor(
+        authenticationService,
+        authenticationUsageService,
+        authenticationMcpUsageService,
+        authenticationAccessService,
+        authenticationMcpAccessService,
+        authenticationExtensionsService,
+        authenticationMcpService,
+        logService
+    ) {
         super();
         this.authenticationService = authenticationService;
         this.authenticationUsageService = authenticationUsageService;
@@ -539,14 +581,14 @@ let AuthenticationQueryService = class AuthenticationQueryService extends Dispos
         this._register(this.authenticationExtensionsService.onDidChangeAccountPreference(e => {
             this._onDidChangePreferences.fire({
                 providerId: e.providerId,
-                entityType: 'extension',
+                entityType: "extension",
                 entityIds: e.extensionIds
             });
         }));
         this._register(this.authenticationMcpService.onDidChangeAccountPreference(e => {
             this._onDidChangePreferences.fire({
                 providerId: e.providerId,
-                entityType: 'mcpServer',
+                entityType: "mcpServer",
                 entityIds: e.mcpServerIds
             });
         }));
@@ -578,8 +620,8 @@ let AuthenticationQueryService = class AuthenticationQueryService extends Dispos
         });
     }
     async clearAllData(confirmation, includeInternal = true) {
-        if (confirmation !== 'CLEAR_ALL_AUTH_DATA') {
-            throw ( new Error('Must provide confirmation string to clear all authentication data'));
+        if (confirmation !== "CLEAR_ALL_AUTH_DATA") {
+            throw ( new Error("Must provide confirmation string to clear all authentication data"));
         }
         const providerIds = this.getProviderIds(includeInternal);
         for (const providerId of providerIds) {
@@ -591,23 +633,13 @@ let AuthenticationQueryService = class AuthenticationQueryService extends Dispos
                     this.authenticationMcpAccessService.removeAllowedMcpServers(providerId, account.label);
                     this.authenticationMcpUsageService.removeAccountUsage(providerId, account.label);
                 }
-            }
-            catch (error) {
+            } catch (error) {
                 this.logService.error(`Error clearing data for provider ${providerId}:`, error);
             }
         }
-        this.logService.info('All authentication data cleared');
+        this.logService.info("All authentication data cleared");
     }
 };
-AuthenticationQueryService = ( __decorate([
-    ( __param(0, IAuthenticationService)),
-    ( __param(1, IAuthenticationUsageService)),
-    ( __param(2, IAuthenticationMcpUsageService)),
-    ( __param(3, IAuthenticationAccessService)),
-    ( __param(4, IAuthenticationMcpAccessService)),
-    ( __param(5, IAuthenticationExtensionsService)),
-    ( __param(6, IAuthenticationMcpService)),
-    ( __param(7, ILogService))
-], AuthenticationQueryService));
+AuthenticationQueryService = ( __decorate([( __param(0, IAuthenticationService)), ( __param(1, IAuthenticationUsageService)), ( __param(2, IAuthenticationMcpUsageService)), ( __param(3, IAuthenticationAccessService)), ( __param(4, IAuthenticationMcpAccessService)), ( __param(5, IAuthenticationExtensionsService)), ( __param(6, IAuthenticationMcpService)), ( __param(7, ILogService))], AuthenticationQueryService));
 
 export { AuthenticationQueryService };

package/vscode/src/vs/workbench/services/authentication/browser/authenticationUsageService.js

@@ -25,15 +25,16 @@ let AuthenticationUsageService = class AuthenticationUsageService extends Dispos
             for (const extensionId of trustedExtensionAuthAccess) {
                 this._extensionsUsingAuth.add(extensionId);
             }
-        }
-        else if (trustedExtensionAuthAccess) {
+        } else if (trustedExtensionAuthAccess) {
             for (const extensions of ( Object.values(trustedExtensionAuthAccess))) {
                 for (const extensionId of extensions) {
                     this._extensionsUsingAuth.add(extensionId);
                 }
             }
         }
-        this._register(this._authenticationService.onDidRegisterAuthenticationProvider(provider => this._queue.queue(() => this._addExtensionsToCache(provider.id))));
+        this._register(this._authenticationService.onDidRegisterAuthenticationProvider(
+            provider => this._queue.queue(() => this._addExtensionsToCache(provider.id))
+        ));
     }
     async initializeExtensionUsageCache() {
         await this._queue.queue(() => Promise.all(( this._authenticationService.getProviderIds().map(providerId => this._addExtensionsToCache(providerId)))));
@@ -49,9 +50,7 @@ let AuthenticationUsageService = class AuthenticationUsageService extends Dispos
         if (storedUsages) {
             try {
                 usages = JSON.parse(storedUsages);
-            }
-            catch (e) {
-            }
+            } catch (e) {}
         }
         return usages;
     }
@@ -70,8 +69,7 @@ let AuthenticationUsageService = class AuthenticationUsageService extends Dispos
                 scopes,
                 lastUsed: Date.now()
             });
-        }
-        else {
+        } else {
             usages.push({
                 extensionId,
                 extensionName,
@@ -79,7 +77,12 @@ let AuthenticationUsageService = class AuthenticationUsageService extends Dispos
                 lastUsed: Date.now()
             });
         }
-        this._storageService.store(accountKey, JSON.stringify(usages), StorageScope.APPLICATION, StorageTarget.MACHINE);
+        this._storageService.store(
+            accountKey,
+            JSON.stringify(usages),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
         this._extensionsUsingAuth.add(extensionId);
     }
     async _addExtensionsToCache(providerId) {
@@ -94,17 +97,11 @@ let AuthenticationUsageService = class AuthenticationUsageService extends Dispos
                     this._extensionsUsingAuth.add(u.extensionId);
                 }
             }
-        }
-        catch (e) {
+        } catch (e) {
             this._logService.error(e);
         }
     }
 };
-AuthenticationUsageService = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IAuthenticationService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IProductService))
-], AuthenticationUsageService));
+AuthenticationUsageService = ( __decorate([( __param(0, IStorageService)), ( __param(1, IAuthenticationService)), ( __param(2, ILogService)), ( __param(3, IProductService))], AuthenticationUsageService));
 
 export { AuthenticationUsageService };

package/vscode/src/vs/workbench/services/authentication/browser/dynamicAuthenticationProviderStorageService.js

@@ -13,8 +13,12 @@ import { Queue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async'
 
 var DynamicAuthenticationProviderStorageService_1;
 let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationProviderStorageService extends Disposable {
-    static { DynamicAuthenticationProviderStorageService_1 = this; }
-    static { this.PROVIDERS_STORAGE_KEY = 'dynamicAuthProviders'; }
+    static {
+        DynamicAuthenticationProviderStorageService_1 = this;
+    }
+    static {
+        this.PROVIDERS_STORAGE_KEY = "dynamicAuthProviders";
+    }
     constructor(storageService, secretStorageService, logService) {
         super();
         this.storageService = storageService;
@@ -23,13 +27,11 @@ let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationPro
         this._onDidChangeTokens = this._register(( new Emitter()));
         this.onDidChangeTokens = this._onDidChangeTokens.event;
         const queue = ( new Queue());
-        this._register(this.secretStorageService.onDidChangeSecret(async (key) => {
+        this._register(this.secretStorageService.onDidChangeSecret(async key => {
             let payload;
             try {
                 payload = JSON.parse(key);
-            }
-            catch (error) {
-            }
+            } catch (error) {}
             if (payload?.isDynamicAuthProvider) {
                 void queue.queue(async () => {
                     const tokens = await this.getSessionsForDynamicAuthProvider(payload.authProviderId, payload.clientId);
@@ -51,14 +53,15 @@ let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationPro
                 if (credentials && (credentials.clientId || credentials.clientSecret)) {
                     return credentials;
                 }
-            }
-            catch {
+            } catch {
                 await this.secretStorageService.delete(key);
             }
         }
         const providers = this._getStoredProviders();
         const provider = providers.find(p => p.providerId === providerId);
-        return provider?.clientId ? { clientId: provider.clientId } : undefined;
+        return provider?.clientId ? {
+            clientId: provider.clientId
+        } : undefined;
     }
     getClientId(providerId) {
         const providers = this._getStoredProviders();
@@ -68,7 +71,10 @@ let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationPro
     async storeClientRegistration(providerId, authorizationServer, clientId, clientSecret, label) {
         this._trackProvider(providerId, authorizationServer, clientId, label);
         const key = `dynamicAuthProvider:clientRegistration:${providerId}`;
-        const credentials = { clientId, clientSecret };
+        const credentials = {
+            clientId,
+            clientSecret
+        };
         await this.secretStorageService.set(key, JSON.stringify(credentials));
     }
     _trackProvider(providerId, authorizationServer, clientId, label) {
@@ -83,8 +89,7 @@ let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationPro
             };
             providers.push(newProvider);
             this._storeProviders(providers);
-        }
-        else {
+        } else {
             const existingProvider = providers[existingProviderIndex];
             const updatedProvider = {
                 providerId,
@@ -97,7 +102,11 @@ let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationPro
         }
     }
     _getStoredProviders() {
-        const stored = this.storageService.get(DynamicAuthenticationProviderStorageService_1.PROVIDERS_STORAGE_KEY, StorageScope.APPLICATION, '[]');
+        const stored = this.storageService.get(
+            DynamicAuthenticationProviderStorageService_1.PROVIDERS_STORAGE_KEY,
+            StorageScope.APPLICATION,
+            "[]"
+        );
         try {
             const providerInfos = JSON.parse(stored);
             for (const providerInfo of providerInfos) {
@@ -106,13 +115,17 @@ let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationPro
                 }
             }
             return providerInfos;
-        }
-        catch {
+        } catch {
             return [];
         }
     }
     _storeProviders(providers) {
-        this.storageService.store(DynamicAuthenticationProviderStorageService_1.PROVIDERS_STORAGE_KEY, JSON.stringify(providers), StorageScope.APPLICATION, StorageTarget.MACHINE);
+        this.storageService.store(
+            DynamicAuthenticationProviderStorageService_1.PROVIDERS_STORAGE_KEY,
+            JSON.stringify(providers),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
     }
     getInteractedProviders() {
         return this._getStoredProviders();
@@ -123,19 +136,30 @@ let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationPro
         const filteredProviders = providers.filter(p => p.providerId !== providerId);
         this._storeProviders(filteredProviders);
         if (providerInfo) {
-            const secretKey = JSON.stringify({ isDynamicAuthProvider: true, authProviderId: providerId, clientId: providerInfo.clientId });
+            const secretKey = JSON.stringify({
+                isDynamicAuthProvider: true,
+                authProviderId: providerId,
+                clientId: providerInfo.clientId
+            });
             await this.secretStorageService.delete(secretKey);
         }
         const credentialsKey = `dynamicAuthProvider:clientRegistration:${providerId}`;
         await this.secretStorageService.delete(credentialsKey);
     }
     async getSessionsForDynamicAuthProvider(authProviderId, clientId) {
-        const key = JSON.stringify({ isDynamicAuthProvider: true, authProviderId, clientId });
+        const key = JSON.stringify({
+            isDynamicAuthProvider: true,
+            authProviderId,
+            clientId
+        });
         const value = await this.secretStorageService.get(key);
         if (value) {
             const parsed = JSON.parse(value);
-            if (!Array.isArray(parsed) || !parsed.every((t) => typeof t.created_at === 'number' && isAuthorizationTokenResponse(t))) {
-                this.logService.error(`Invalid session data for ${authProviderId} (${clientId}) in secret storage:`, parsed);
+            if (!Array.isArray(parsed) || !parsed.every(t => typeof t.created_at === "number" && isAuthorizationTokenResponse(t))) {
+                this.logService.error(
+                    `Invalid session data for ${authProviderId} (${clientId}) in secret storage:`,
+                    parsed
+                );
                 await this.secretStorageService.delete(key);
                 return undefined;
             }
@@ -144,16 +168,19 @@ let DynamicAuthenticationProviderStorageService = class DynamicAuthenticationPro
         return undefined;
     }
     async setSessionsForDynamicAuthProvider(authProviderId, clientId, sessions) {
-        const key = JSON.stringify({ isDynamicAuthProvider: true, authProviderId, clientId });
+        const key = JSON.stringify({
+            isDynamicAuthProvider: true,
+            authProviderId,
+            clientId
+        });
         const value = JSON.stringify(sessions);
         await this.secretStorageService.set(key, value);
-        this.logService.trace(`Set session data for ${authProviderId} (${clientId}) in secret storage:`, sessions);
+        this.logService.trace(
+            `Set session data for ${authProviderId} (${clientId}) in secret storage:`,
+            sessions
+        );
     }
 };
-DynamicAuthenticationProviderStorageService = DynamicAuthenticationProviderStorageService_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, ISecretStorageService)),
-    ( __param(2, ILogService))
-], DynamicAuthenticationProviderStorageService));
+DynamicAuthenticationProviderStorageService = DynamicAuthenticationProviderStorageService_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, ISecretStorageService)), ( __param(2, ILogService))], DynamicAuthenticationProviderStorageService));
 
 export { DynamicAuthenticationProviderStorageService };