@gooddata/sdk-backend-base 9.6.0-alpha.6 → 9.6.0-alpha.8

package/esm/cachingBackend/index.js

@@ -19,32 +19,33 @@ import { DecoratedWorkspaceSettingsService } from "../decoratedBackend/workspace
 // Execution caching
 //
 class WithExecutionCaching extends DecoratedPreparedExecution {
+    ctx;
     constructor(decorated, ctx) {
         super(decorated);
         this.ctx = ctx;
-        this.execute = async () => {
-            const cacheKey = this.fingerprint();
-            const cache = this.ctx.caches.execution;
-            let cacheEntry = cache.get(cacheKey);
-            if (!cacheEntry) {
-                const result = super
-                    .execute()
-                    .then((res) => {
-                    return new WithExecutionResultCaching(res, this.createNew, this.ctx);
-                })
-                    .catch((e) => {
-                    cache.delete(cacheKey);
-                    throw e;
-                });
-                cacheEntry = { result };
-                cache.set(cacheKey, cacheEntry);
-            }
-            return new DefinitionSanitizingExecutionResult(await cacheEntry.result, this.createNew, this.definition);
-        };
-        this.createNew = (decorated) => {
-            return new WithExecutionCaching(decorated, this.ctx);
-        };
     }
+    execute = async () => {
+        const cacheKey = this.fingerprint();
+        const cache = this.ctx.caches.execution;
+        let cacheEntry = cache.get(cacheKey);
+        if (!cacheEntry) {
+            const result = super
+                .execute()
+                .then((res) => {
+                return new WithExecutionResultCaching(res, this.createNew, this.ctx);
+            })
+                .catch((e) => {
+                cache.delete(cacheKey);
+                throw e;
+            });
+            cacheEntry = { result };
+            cache.set(cacheKey, cacheEntry);
+        }
+        return new DefinitionSanitizingExecutionResult(await cacheEntry.result, this.createNew, this.definition);
+    };
+    createNew = (decorated) => {
+        return new WithExecutionCaching(decorated, this.ctx);
+    };
 }
 /**
  * This DataView decorator makes sure that definition used in it is the same as the definition in the result.
@@ -69,55 +70,58 @@ class DefinitionSanitizingDataView extends DecoratedDataView {
 class DefinitionSanitizingExecutionResult extends DecoratedExecutionResult {
     constructor(decorated, wrapper, definitionOverride) {
         super(decorated, wrapper);
-        this.readAll = async () => {
-            return this.withSanitizedDefinition(await super.readAll());
-        };
-        this.readWindow = async (offset, size) => {
-            return this.withSanitizedDefinition(await super.readWindow(offset, size));
-        };
-        this.withSanitizedDefinition = (original) => {
-            return new DefinitionSanitizingDataView(original, this);
-        };
         this.definition = definitionOverride;
     }
+    readAll = async () => {
+        return this.withSanitizedDefinition(await super.readAll());
+    };
+    readWindow = async (offset, size) => {
+        return this.withSanitizedDefinition(await super.readWindow(offset, size));
+    };
+    withSanitizedDefinition = (original) => {
+        return new DefinitionSanitizingDataView(original, this);
+    };
 }
 function windowKey(offset, size) {
     return `o(${offset.join(",")})_s(${size.join(",")})`;
 }
 class WithExecutionResultCaching extends DecoratedExecutionResult {
+    ctx;
+    allData;
+    windows;
     constructor(decorated, wrapper, ctx) {
         super(decorated, wrapper);
         this.ctx = ctx;
-        this.readAll = () => {
-            if (!this.allData) {
-                this.allData = super.readAll().catch((e) => {
-                    this.allData = undefined;
-                    throw e;
-                });
-            }
-            return this.allData;
-        };
-        this.readWindow = (offset, size) => {
-            if (!this.windows) {
-                return super.readWindow(offset, size);
-            }
-            const cacheKey = windowKey(offset, size);
-            let window = this.windows.get(cacheKey);
-            if (!window) {
-                window = super.readWindow(offset, size).catch((e) => {
-                    if (this.windows) {
-                        this.windows.delete(cacheKey);
-                    }
-                    throw e;
-                });
-                this.windows.set(cacheKey, window);
-            }
-            return window;
-        };
         if (cachingEnabled(this.ctx.config.maxResultWindows)) {
             this.windows = new LRUCache({ max: this.ctx.config.maxResultWindows });
         }
     }
+    readAll = () => {
+        if (!this.allData) {
+            this.allData = super.readAll().catch((e) => {
+                this.allData = undefined;
+                throw e;
+            });
+        }
+        return this.allData;
+    };
+    readWindow = (offset, size) => {
+        if (!this.windows) {
+            return super.readWindow(offset, size);
+        }
+        const cacheKey = windowKey(offset, size);
+        let window = this.windows.get(cacheKey);
+        if (!window) {
+            window = super.readWindow(offset, size).catch((e) => {
+                if (this.windows) {
+                    this.windows.delete(cacheKey);
+                }
+                throw e;
+            });
+            this.windows.set(cacheKey, window);
+        }
+        return window;
+    };
 }
 //
 // Catalog caching
@@ -126,39 +130,40 @@ function optionsKey(options) {
     return stringify(options);
 }
 class WithCatalogCaching extends DecoratedWorkspaceCatalogFactory {
+    ctx;
     constructor(decorated, ctx) {
         super(decorated);
         this.ctx = ctx;
-        this.load = () => {
-            const cache = this.getOrCreateWorkspaceEntry(this.workspace).catalogForOptions;
-            const cacheKey = optionsKey(this.options);
-            let catalog = cache.get(cacheKey);
-            if (!catalog) {
-                catalog = super.load().catch((e) => {
-                    cache.delete(cacheKey);
-                    throw e;
-                });
-                cache.set(cacheKey, catalog);
-            }
-            return catalog;
-        };
-        this.createNew = (decorated) => {
-            return new WithCatalogCaching(decorated, this.ctx);
-        };
-        this.getOrCreateWorkspaceEntry = (workspace) => {
-            const cache = this.ctx.caches.workspaceCatalogs;
-            let cacheEntry = cache.get(workspace);
-            if (!cacheEntry) {
-                cacheEntry = {
-                    catalogForOptions: new LRUCache({
-                        max: this.ctx.config.maxCatalogOptions,
-                    }),
-                };
-                cache.set(workspace, cacheEntry);
-            }
-            return cacheEntry;
-        };
     }
+    load = () => {
+        const cache = this.getOrCreateWorkspaceEntry(this.workspace).catalogForOptions;
+        const cacheKey = optionsKey(this.options);
+        let catalog = cache.get(cacheKey);
+        if (!catalog) {
+            catalog = super.load().catch((e) => {
+                cache.delete(cacheKey);
+                throw e;
+            });
+            cache.set(cacheKey, catalog);
+        }
+        return catalog;
+    };
+    createNew = (decorated) => {
+        return new WithCatalogCaching(decorated, this.ctx);
+    };
+    getOrCreateWorkspaceEntry = (workspace) => {
+        const cache = this.ctx.caches.workspaceCatalogs;
+        let cacheEntry = cache.get(workspace);
+        if (!cacheEntry) {
+            cacheEntry = {
+                catalogForOptions: new LRUCache({
+                    max: this.ctx.config.maxCatalogOptions,
+                }),
+            };
+            cache.set(workspace, cacheEntry);
+        }
+        return cacheEntry;
+    };
 }
 //
 // Organization security settings caching
@@ -167,86 +172,73 @@ function validUrlInContextKey(url, context) {
     return `${context}_${stringify(url)}`;
 }
 class WithSecuritySettingsCaching extends DecoratedSecuritySettingsService {
+    ctx;
     constructor(decorated, ctx) {
         super(decorated);
         this.ctx = ctx;
-        this.isUrlValid = (url, context) => {
-            const cache = this.getOrCreateSecuritySettingsEntry(this.scope).valid;
-            const cacheKey = validUrlInContextKey(url, context);
-            let result = cache.get(cacheKey);
-            if (!result) {
-                result = super.isUrlValid(url, context).catch((e) => {
-                    cache.delete(cacheKey);
-                    throw e;
-                });
-                cache.set(cacheKey, result);
-            }
-            return result;
-        };
-        this.isDashboardPluginUrlValid = (url, workspace) => {
-            const scope = `plugins_${workspace}`;
-            const cache = this.getOrCreateSecuritySettingsEntry(scope).valid;
-            let result = cache.get(url);
-            if (!result) {
-                result = super.isDashboardPluginUrlValid(url, workspace).catch((e) => {
-                    cache.delete(url);
-                    throw e;
-                });
-                cache.set(url, result);
-            }
-            return result;
-        };
-        this.getOrCreateSecuritySettingsEntry = (scope) => {
-            const cache = this.ctx.caches.securitySettings;
-            let cacheEntry = cache.get(scope);
-            if (!cacheEntry) {
-                cacheEntry = {
-                    valid: new LRUCache({
-                        max: this.ctx.config.maxSecuritySettingsOrgUrls,
-                        ttl: this.ctx.config.maxSecuritySettingsOrgUrlsAge,
-                    }),
-                };
-                cache.set(scope, cacheEntry);
-            }
-            return cacheEntry;
-        };
     }
+    isUrlValid = (url, context) => {
+        const cache = this.getOrCreateSecuritySettingsEntry(this.scope).valid;
+        const cacheKey = validUrlInContextKey(url, context);
+        let result = cache.get(cacheKey);
+        if (!result) {
+            result = super.isUrlValid(url, context).catch((e) => {
+                cache.delete(cacheKey);
+                throw e;
+            });
+            cache.set(cacheKey, result);
+        }
+        return result;
+    };
+    isDashboardPluginUrlValid = (url, workspace) => {
+        const scope = `plugins_${workspace}`;
+        const cache = this.getOrCreateSecuritySettingsEntry(scope).valid;
+        let result = cache.get(url);
+        if (!result) {
+            result = super.isDashboardPluginUrlValid(url, workspace).catch((e) => {
+                cache.delete(url);
+                throw e;
+            });
+            cache.set(url, result);
+        }
+        return result;
+    };
+    getOrCreateSecuritySettingsEntry = (scope) => {
+        const cache = this.ctx.caches.securitySettings;
+        let cacheEntry = cache.get(scope);
+        if (!cacheEntry) {
+            cacheEntry = {
+                valid: new LRUCache({
+                    max: this.ctx.config.maxSecuritySettingsOrgUrls,
+                    ttl: this.ctx.config.maxSecuritySettingsOrgUrlsAge,
+                }),
+            };
+            cache.set(scope, cacheEntry);
+        }
+        return cacheEntry;
+    };
 }
 class WithWorkspaceSettingsCaching extends DecoratedWorkspaceSettingsService {
+    ctx;
+    workspace;
     constructor(decorated, ctx, workspace) {
         super(decorated);
         this.ctx = ctx;
         this.workspace = workspace;
-        this.getSettings = () => {
-            const cache = this.getOrCreateWorkspaceEntry(this.workspace).workspaceSettings;
-            const cacheKey = this.workspace;
-            let workspaceSettings = cache.get(cacheKey);
-            if (!workspaceSettings) {
-                workspaceSettings = super.getSettings().catch((e) => {
-                    cache.delete(cacheKey);
-                    throw e;
-                });
-                cache.set(cacheKey, workspaceSettings);
-            }
-            return workspaceSettings;
-        };
-        this.getOrCreateWorkspaceEntry = (workspace) => {
-            const cache = this.ctx.caches.workspaceSettings;
-            let cacheEntry = cache.get(workspace);
-            if (!cacheEntry) {
-                cacheEntry = {
-                    userWorkspaceSettings: new LRUCache({
-                        max: this.ctx.config.maxWorkspaceSettings,
-                    }),
-                    workspaceSettings: new LRUCache({
-                        max: this.ctx.config.maxWorkspaceSettings,
-                    }),
-                };
-                cache.set(workspace, cacheEntry);
-            }
-            return cacheEntry;
-        };
     }
+    getSettings = () => {
+        const cache = this.getOrCreateWorkspaceEntry(this.workspace).workspaceSettings;
+        const cacheKey = this.workspace;
+        let workspaceSettings = cache.get(cacheKey);
+        if (!workspaceSettings) {
+            workspaceSettings = super.getSettings().catch((e) => {
+                cache.delete(cacheKey);
+                throw e;
+            });
+            cache.set(cacheKey, workspaceSettings);
+        }
+        return workspaceSettings;
+    };
     getSettingsForCurrentUser() {
         const cache = this.getOrCreateWorkspaceEntry(this.workspace).userWorkspaceSettings;
         const cacheKey = this.workspace; // we assume that the current user does not change over the life span of the backend instance
@@ -269,6 +261,22 @@ class WithWorkspaceSettingsCaching extends DecoratedWorkspaceSettingsService {
     async setTheme(themeId) {
         return super.setTheme(themeId);
     }
+    getOrCreateWorkspaceEntry = (workspace) => {
+        const cache = this.ctx.caches.workspaceSettings;
+        let cacheEntry = cache.get(workspace);
+        if (!cacheEntry) {
+            cacheEntry = {
+                userWorkspaceSettings: new LRUCache({
+                    max: this.ctx.config.maxWorkspaceSettings,
+                }),
+                workspaceSettings: new LRUCache({
+                    max: this.ctx.config.maxWorkspaceSettings,
+                }),
+            };
+            cache.set(workspace, cacheEntry);
+        }
+        return cacheEntry;
+    };
 }
 //
 // Attributes caching
@@ -304,36 +312,40 @@ function getOrCreateAttributeCache(ctx, workspace) {
     return cacheEntry;
 }
 class CachedElementsQuery extends DecoratedElementsQuery {
+    ctx;
+    workspace;
+    ref;
     constructor(decorated, ctx, workspace, ref, settings = {}) {
         super(decorated, settings);
         this.ctx = ctx;
         this.workspace = workspace;
         this.ref = ref;
-        this.query = async () => {
-            var _a;
-            const canCache = !((_a = this.settings.options) === null || _a === void 0 ? void 0 : _a.filter);
-            if (!canCache) {
-                return super.query();
-            }
-            const cache = getOrCreateAttributeCache(this.ctx, this.workspace).attributeElementResults;
-            invariant(cache, "inconsistent attribute element cache config");
-            const cacheKey = elementsCacheKey(this.ref, this.settings);
-            let result = cache.get(cacheKey);
-            if (!result) {
-                result = super.query().catch((e) => {
-                    cache.delete(cacheKey);
-                    throw e;
-                });
-                cache.set(cacheKey, result);
-            }
-            return result;
-        };
     }
+    query = async () => {
+        const canCache = !this.settings.options?.filter;
+        if (!canCache) {
+            return super.query();
+        }
+        const cache = getOrCreateAttributeCache(this.ctx, this.workspace).attributeElementResults;
+        invariant(cache, "inconsistent attribute element cache config");
+        const cacheKey = elementsCacheKey(this.ref, this.settings);
+        let result = cache.get(cacheKey);
+        if (!result) {
+            result = super.query().catch((e) => {
+                cache.delete(cacheKey);
+                throw e;
+            });
+            cache.set(cacheKey, result);
+        }
+        return result;
+    };
     createNew(decorated, settings) {
         return new CachedElementsQuery(decorated, this.ctx, this.workspace, this.ref, settings);
     }
 }
 class CachedElementsQueryFactory extends DecoratedElementsQueryFactory {
+    ctx;
+    workspace;
     constructor(decorated, ctx, workspace) {
         super(decorated);
         this.ctx = ctx;
@@ -345,98 +357,100 @@ class CachedElementsQueryFactory extends DecoratedElementsQueryFactory {
     }
 }
 class WithAttributesCaching extends DecoratedWorkspaceAttributesService {
+    ctx;
+    workspace;
     constructor(decorated, ctx, workspace) {
         super(decorated);
         this.ctx = ctx;
         this.workspace = workspace;
-        this.getAttributeDisplayForm = (ref) => {
-            const cache = getOrCreateAttributeCache(this.ctx, this.workspace).displayForms;
-            const idCacheKey = isIdentifierRef(ref) ? ref.identifier : undefined;
-            const uriCacheKey = isUriRef(ref) ? ref.uri : undefined;
-            let cacheItem = firstDefined([idCacheKey, uriCacheKey].map((key) => key && cache.get(key)));
-            if (!cacheItem) {
-                cacheItem = super.getAttributeDisplayForm(ref).catch((e) => {
-                    if (idCacheKey) {
-                        cache.delete(idCacheKey);
-                    }
-                    if (uriCacheKey) {
-                        cache.delete(uriCacheKey);
-                    }
-                    throw e;
-                });
+    }
+    getAttributeDisplayForm = (ref) => {
+        const cache = getOrCreateAttributeCache(this.ctx, this.workspace).displayForms;
+        const idCacheKey = isIdentifierRef(ref) ? ref.identifier : undefined;
+        const uriCacheKey = isUriRef(ref) ? ref.uri : undefined;
+        let cacheItem = firstDefined([idCacheKey, uriCacheKey].map((key) => key && cache.get(key)));
+        if (!cacheItem) {
+            cacheItem = super.getAttributeDisplayForm(ref).catch((e) => {
                 if (idCacheKey) {
-                    cache.set(idCacheKey, cacheItem);
+                    cache.delete(idCacheKey);
                 }
                 if (uriCacheKey) {
-                    cache.set(uriCacheKey, cacheItem);
+                    cache.delete(uriCacheKey);
                 }
-            }
-            return cacheItem;
-        };
-        this.getAttributeDisplayForms = async (refs) => {
-            const cache = getOrCreateAttributeCache(this.ctx, this.workspace).displayForms;
-            // grab a reference to the cache results as soon as possible in case they would get evicted while loading the ones with missing data in cache
-            // then would might not be able to call cache.get again and be guaranteed to get the data
-            const refsWithCacheResults = refs.map((ref) => {
-                const idCacheKey = isIdentifierRef(ref) ? ref.identifier : undefined;
-                const uriCacheKey = isUriRef(ref) ? ref.uri : undefined;
-                const cacheHit = firstDefined([idCacheKey, uriCacheKey].map((key) => key && cache.get(key)));
-                return { ref, cacheHit };
-            });
-            const [withCacheHits, withoutCacheHits] = partition(refsWithCacheResults, ({ cacheHit }) => !!cacheHit);
-            const refsToLoad = withoutCacheHits.map((item) => item.ref);
-            const [alreadyInCache, loadedFromServer] = await Promise.all([
-                // await the stuff from cache, we need the data available (we cannot just return the promises)
-                Promise.all(withCacheHits.map((item) => item.cacheHit)),
-                // load items not in cache using the bulk operation
-                this.decorated.getAttributeDisplayForms(refsToLoad),
-            ]);
-            // save newly loaded to cache for future reference
-            loadedFromServer.forEach((loaded) => {
-                const promisifiedResult = Promise.resolve(loaded);
-                // save the cache item for both types of refs
-                cache.set(loaded.id, promisifiedResult);
-                cache.set(loaded.uri, promisifiedResult);
-            });
-            const loadedRefs = loadedFromServer.map((item) => item.ref);
-            const outputRefs = this.ctx.capabilities.allowsInconsistentRelations
-                ? skipMissingReferences(refs, refsToLoad, loadedRefs)
-                : refs;
-            // reconstruct the original ordering
-            const candidates = [...loadedFromServer, ...alreadyInCache];
-            return outputRefs.map((ref) => {
-                const match = candidates.find((item) => refMatchesMdObject(ref, item, "displayForm"));
-                // if this bombs, some data got lost in the process
-                invariant(match);
-                return match;
+                throw e;
             });
-        };
-        this.getAttributeByDisplayForm = async (ref) => {
-            const cache = getOrCreateAttributeCache(this.ctx, this.workspace).attributesByDisplayForms;
+            if (idCacheKey) {
+                cache.set(idCacheKey, cacheItem);
+            }
+            if (uriCacheKey) {
+                cache.set(uriCacheKey, cacheItem);
+            }
+        }
+        return cacheItem;
+    };
+    getAttributeDisplayForms = async (refs) => {
+        const cache = getOrCreateAttributeCache(this.ctx, this.workspace).displayForms;
+        // grab a reference to the cache results as soon as possible in case they would get evicted while loading the ones with missing data in cache
+        // then would might not be able to call cache.get again and be guaranteed to get the data
+        const refsWithCacheResults = refs.map((ref) => {
             const idCacheKey = isIdentifierRef(ref) ? ref.identifier : undefined;
             const uriCacheKey = isUriRef(ref) ? ref.uri : undefined;
-            let cacheItem = firstDefined([idCacheKey, uriCacheKey].map((key) => key && cache.get(key)));
-            if (!cacheItem) {
-                // eslint-disable-next-line sonarjs/no-identical-functions
-                cacheItem = super.getAttributeByDisplayForm(ref).catch((e) => {
-                    if (idCacheKey) {
-                        cache.delete(idCacheKey);
-                    }
-                    if (uriCacheKey) {
-                        cache.delete(uriCacheKey);
-                    }
-                    throw e;
-                });
+            const cacheHit = firstDefined([idCacheKey, uriCacheKey].map((key) => key && cache.get(key)));
+            return { ref, cacheHit };
+        });
+        const [withCacheHits, withoutCacheHits] = partition(refsWithCacheResults, ({ cacheHit }) => !!cacheHit);
+        const refsToLoad = withoutCacheHits.map((item) => item.ref);
+        const [alreadyInCache, loadedFromServer] = await Promise.all([
+            // await the stuff from cache, we need the data available (we cannot just return the promises)
+            Promise.all(withCacheHits.map((item) => item.cacheHit)),
+            // load items not in cache using the bulk operation
+            this.decorated.getAttributeDisplayForms(refsToLoad),
+        ]);
+        // save newly loaded to cache for future reference
+        loadedFromServer.forEach((loaded) => {
+            const promisifiedResult = Promise.resolve(loaded);
+            // save the cache item for both types of refs
+            cache.set(loaded.id, promisifiedResult);
+            cache.set(loaded.uri, promisifiedResult);
+        });
+        const loadedRefs = loadedFromServer.map((item) => item.ref);
+        const outputRefs = this.ctx.capabilities.allowsInconsistentRelations
+            ? skipMissingReferences(refs, refsToLoad, loadedRefs)
+            : refs;
+        // reconstruct the original ordering
+        const candidates = [...loadedFromServer, ...alreadyInCache];
+        return outputRefs.map((ref) => {
+            const match = candidates.find((item) => refMatchesMdObject(ref, item, "displayForm"));
+            // if this bombs, some data got lost in the process
+            invariant(match);
+            return match;
+        });
+    };
+    getAttributeByDisplayForm = async (ref) => {
+        const cache = getOrCreateAttributeCache(this.ctx, this.workspace).attributesByDisplayForms;
+        const idCacheKey = isIdentifierRef(ref) ? ref.identifier : undefined;
+        const uriCacheKey = isUriRef(ref) ? ref.uri : undefined;
+        let cacheItem = firstDefined([idCacheKey, uriCacheKey].map((key) => key && cache.get(key)));
+        if (!cacheItem) {
+            // eslint-disable-next-line sonarjs/no-identical-functions
+            cacheItem = super.getAttributeByDisplayForm(ref).catch((e) => {
                 if (idCacheKey) {
-                    cache.set(idCacheKey, cacheItem);
+                    cache.delete(idCacheKey);
                 }
                 if (uriCacheKey) {
-                    cache.set(uriCacheKey, cacheItem);
+                    cache.delete(uriCacheKey);
                 }
+                throw e;
+            });
+            if (idCacheKey) {
+                cache.set(idCacheKey, cacheItem);
             }
-            return cacheItem;
-        };
-    }
+            if (uriCacheKey) {
+                cache.set(uriCacheKey, cacheItem);
+            }
+        }
+        return cacheItem;
+    };
     elements() {
         const decorated = this.decorated.elements();
         return cachingEnabled(this.ctx.config.maxAttributeElementResultsPerWorkspace)
@@ -468,24 +482,19 @@ function cachingEnabled(desiredSize) {
 function cacheControl(ctx) {
     const control = {
         resetExecutions: () => {
-            var _a;
-            (_a = ctx.caches.execution) === null || _a === void 0 ? void 0 : _a.clear();
+            ctx.caches.execution?.clear();
         },
         resetCatalogs: () => {
-            var _a;
-            (_a = ctx.caches.workspaceCatalogs) === null || _a === void 0 ? void 0 : _a.clear();
+            ctx.caches.workspaceCatalogs?.clear();
         },
         resetSecuritySettings: () => {
-            var _a;
-            (_a = ctx.caches.securitySettings) === null || _a === void 0 ? void 0 : _a.clear();
+            ctx.caches.securitySettings?.clear();
         },
         resetAttributes: () => {
-            var _a;
-            (_a = ctx.caches.workspaceAttributes) === null || _a === void 0 ? void 0 : _a.clear();
+            ctx.caches.workspaceAttributes?.clear();
         },
         resetWorkspaceSettings: () => {
-            var _a;
-            (_a = ctx.caches.workspaceSettings) === null || _a === void 0 ? void 0 : _a.clear();
+            ctx.caches.workspaceSettings?.clear();
         },
         resetAll: () => {
             control.resetExecutions();