@pb33f/cowboy-components 0.7.5 → 0.7.7

package/dist/controllers/rule-controller.js

@@ -0,0 +1,264 @@
+import { AllRulesetBag, CustomRulesetBag, DefaultDocument, DefaultRulesetBag, OWASPRulesetBag, RuleConfigurationBag, SessionRulesetMapBag } from "../components/the-doctor/the-doctor";
+import { ActiveView, ProblemRuleFilterChangedManual } from "../events/doctor";
+import { RulesetService } from "../services/ruleset-service";
+import { ToastType } from "../model/toast";
+import { MarkerSeverity } from "monaco-editor";
+export class RuleController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    ruleClicked(evt) {
+        // get rule map from bag
+        const map = this.doc.sessionRulesetMapBag?.get(SessionRulesetMapBag);
+        if (map) {
+            const rule = map.rulesMap.find((r) => r.ruleId === evt.detail.ruleId);
+            if (rule) {
+                this.doc.selectedEditorTab = "ruleset";
+                this.doc.editorTabGroup.show(ActiveView.Ruleset);
+                this.doc.rulesetEditor.editor?.setPosition({ lineNumber: rule.line, column: rule.start });
+                this.doc.rulesetEditor.editor?.revealLineInCenter(rule.line);
+            }
+        }
+    }
+    rulesetSaved(evt) {
+        // lint spec
+        if (this.doc.docBag) {
+            const doc = this.doc.docBag.get(DefaultDocument);
+            const config = this.doc.ruleConfigBag?.get(RuleConfigurationBag);
+            if (evt.detail.rules) {
+                this.doc.customRulesetBag?.set(CustomRulesetBag, evt.detail.rules);
+                // get ruleset config and disable everything,
+                // then enable the custom rules.
+                if (config) {
+                    // extract config from the event
+                    const newConfig = evt.detail.config;
+                    if (newConfig && this.doc.ruleConfigBag) {
+                        newConfig.returnedRuleset = evt.detail.returnedRules;
+                        this.doc.ruleConfigBag?.set(RuleConfigurationBag, newConfig);
+                    }
+                }
+                RulesetService.getSessionRulesetAsYAML().then((yaml) => {
+                    if (this.doc.selectedEditorTab == "spec") {
+                        this.doc.rulesetPulse = true;
+                    }
+                    this.doc.rulesetEditor.setValue(yaml, true);
+                    this.fetchRulesetMap();
+                });
+                // lint the spec
+                this.doc.diagnosticController.lintSpec(doc, '');
+            }
+        }
+    }
+    customRulesetEnabled(event) {
+        const customRS = { rules: new Map() };
+        customRS.id = crypto.randomUUID();
+        customRS.owner = this.doc.authController.session.sessionId;
+        event.detail.rules.forEach((rule) => {
+            if (rule.rule.id != rule.ruleId) {
+                rule.rule.id = rule.ruleId;
+            }
+            customRS.rules.set(rule.ruleId, rule.rule);
+        });
+        // write state
+        this.doc.customRulesetBag?.set(CustomRulesetBag, customRS);
+        if (event.detail.ruleConfig) {
+            this.doc.ruleConfigBag?.set(RuleConfigurationBag, event.detail.ruleConfig);
+        }
+        else {
+            this.doc.ruleConfigBag?.reset();
+            // reset session ruleset
+            RulesetService.resetSessionRuleset(event.detail.rulesetReset).then(() => {
+                this.doc.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.INFO,
+                    body: "Ruleset has been reset to the default",
+                    title: "Ruleset reset",
+                });
+                if (this.doc.docBag) {
+                    const doc = this.doc.docBag.get(DefaultDocument);
+                    let path = this.doc.rolodexActivePath;
+                    if (path == 'root') {
+                        path = "";
+                    }
+                    this.doc.diagnosticController.lintSpec(doc, this.doc.rolodexActivePath);
+                }
+                this.fetchSessionRulesetAsYaml().then((result) => {
+                    this.doc.rulesetEditor?.setValue(result, true);
+                });
+            }).catch((e) => {
+                this.doc.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    body: e.detail,
+                    title: "Cannot reset ruleset",
+                });
+            });
+        }
+    }
+    ruleGroupClicked(event) {
+        this.doc.problemsPanel.focus();
+        const simEvent = new CustomEvent(ProblemRuleFilterChangedManual, {
+            bubbles: true,
+            composed: true,
+            detail: {
+                rule: event.detail.rule
+            }
+        });
+        this.doc.problemsPanel.focus();
+        this.doc.problemList.dispatchEvent(simEvent);
+        history.pushState({ rule: event.detail.rule }, "", `/${ActiveView.Problems}?rule=${event.detail.rule}`);
+        this.doc.controlTabGroup.show(ActiveView.Problems);
+    }
+    rulesetManuallyChanged() {
+        clearTimeout(this.doc.bounceId);
+        this.doc.bounceId = window.setTimeout(() => {
+            const ruleset = this.doc.rulesetEditor.editor?.getValue();
+            RulesetService.validateRuleset(ruleset).then((result) => {
+                // clear any problems
+                this.doc.manageRuleset.clearRuleProblems();
+                // create a new custom ruleset with a map of rules
+                let customRS = { rules: new Map() };
+                customRS.id = crypto.randomUUID();
+                customRS.owner = this.doc.authController.session.sessionId;
+                customRS.rules = new Map(Object.entries(result.rules));
+                customRS.rules.forEach((rule, id) => {
+                    rule.id = id; // set the id to the key
+                });
+                // write state
+                this.doc.customRulesetBag?.set(CustomRulesetBag, customRS);
+                this.doc.customRuleset = customRS;
+                if (customRS.rules.size > 0) {
+                    // rebuild the ruleset management
+                    this.doc.manageRuleset.customRulesetManual = customRS;
+                }
+                this.doc.selectedEditorTab = ActiveView.Ruleset;
+                this.doc.controlTabGroup.show(ActiveView.Ruleset);
+                this.doc.rulesetEditor.setMarkers([]);
+                this.fetchRulesetMap();
+            }).catch((e) => {
+                this.doc.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    body: e.detail,
+                    title: e.title
+                });
+                console.error('unable to validate ruleset', e);
+                // process bad rules
+                const ruleErrors = e.body;
+                const markers = [];
+                ruleErrors?.forEach((err) => {
+                    markers.push({
+                        severity: MarkerSeverity.Error,
+                        message: err.ruleError,
+                        startLineNumber: err.line,
+                        startColumn: err.startCol,
+                        endLineNumber: err.line,
+                        endColumn: err.endCol
+                    });
+                });
+                // convert to JSON
+                RulesetService.convertToJSON(ruleset).then((json) => {
+                    // create a new custom ruleset with a map of rules
+                    let customRS = { rules: new Map() };
+                    customRS.id = crypto.randomUUID();
+                    customRS.owner = this.doc.authController.session.sessionId;
+                    customRS.rules = new Map(Object.entries(json.rules));
+                    customRS.rules.forEach((rule, id) => {
+                        if (rule.id != id)
+                            rule.id = id; // set the id to the key
+                    });
+                    this.doc.customRuleset = customRS;
+                    if (customRS.rules.size > 0) {
+                        // rebuild the ruleset management
+                        this.doc.manageRuleset.customRulesetManual = customRS;
+                    }
+                    this.doc.rulesetEditor.setMarkers([]);
+                    // clear any problems
+                    this.doc.manageRuleset.clearRuleProblems();
+                    // set problems.
+                    this.doc.rulesetEditor.setMarkers(markers);
+                    this.doc.manageRuleset.processBadRules(ruleErrors);
+                    this.doc.controlTabGroup.show(ActiveView.Ruleset);
+                }).catch((e) => {
+                    console.error("unable to convert ruleset to JSON", e);
+                });
+            });
+        }, this.doc.debounceTimeRuleset);
+    }
+    fetchRulesetMap() {
+        RulesetService.getSessionRulesetMap().then((result) => {
+            this.doc.sessionRulesetMapBag?.set(SessionRulesetMapBag, result);
+        }).catch(() => {
+            console.warn("map is empty, or unavailable, Did you submit an empty ruleset?");
+            this.doc.sendToast({
+                id: crypto.randomUUID(),
+                type: ToastType.WARNING,
+                body: "map is empty, or unavailable, Did you submit an empty ruleset?",
+                title: "Issue fetching ruleset map"
+            });
+        });
+    }
+    exportJSON() {
+        let jsonRS;
+        if (this.doc.ruleConfigBag) {
+            const config = this.doc.ruleConfigBag.get(RuleConfigurationBag);
+            if (config && config.returnedRuleset) {
+                jsonRS = config.returnedRuleset;
+            }
+        }
+        if (jsonRS) {
+            let reportData = "data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(jsonRS, null, 2));
+            this.doc.downloadRulesetLink.download = "ruleset.json";
+            this.doc.downloadRulesetLink.href = reportData;
+            this.doc.downloadRulesetLink.click();
+            this.doc.exportRulesetDialog.hide();
+        }
+    }
+    exportYAML() {
+        RulesetService.getSessionRulesetAsYAML().then((yaml) => {
+            let reportData = "data:text/yaml;charset=utf-8," + encodeURIComponent(yaml);
+            this.doc.downloadRulesetLink.download = "ruleset.yaml";
+            this.doc.downloadRulesetLink.href = reportData;
+            this.doc.downloadRulesetLink.click();
+            this.doc.exportRulesetDialog.hide();
+        });
+    }
+    async fetchSessionRulesetAsYaml() {
+        return new Promise(async (resolve, reject) => {
+            RulesetService.getSessionRulesetAsYAML().then((result) => {
+                resolve(result);
+            }).catch((e) => {
+                console.error("cannot fetch session ruleset: ", e.title);
+                reject(e);
+            });
+        });
+    }
+    async fetchAllRuleset() {
+        return new Promise(async (resolve) => {
+            RulesetService.getAllRuleset().then((result) => {
+                this.doc.allRuleset = result;
+                this.doc.allRulesetBag?.set(AllRulesetBag, result);
+                resolve(result);
+            });
+        });
+    }
+    async fetchDefaultRuleset() {
+        return new Promise(async (resolve) => {
+            RulesetService.getDefaultRuleset().then((result) => {
+                this.doc.defaultRuleset = result;
+                this.doc.defaultRulesetBag?.set(DefaultRulesetBag, result);
+                resolve(result);
+            });
+        });
+    }
+    async fetchOWASPRuleset() {
+        return new Promise(async (resolve) => {
+            RulesetService.getOWASPRuleset().then((result) => {
+                this.doc.OWASPRuleset = result;
+                this.doc.OWASPRulesetBag?.set(OWASPRulesetBag, result);
+                resolve(result);
+            });
+        });
+    }
+}

package/dist/controllers/spec-controller.d.ts

@@ -0,0 +1,8 @@
+import { TheDoctor } from "../components/the-doctor/the-doctor";
+import { EditorClickedEvent, EditorUpdatedEvent } from "../events/doctor";
+export declare class SpecController extends EventTarget {
+    doc: TheDoctor;
+    constructor(doc: TheDoctor);
+    specChanged(event: CustomEvent<EditorUpdatedEvent>): void;
+    specClicked(event: CustomEvent<EditorClickedEvent>): void;
+}

package/dist/controllers/spec-controller.js

@@ -0,0 +1,78 @@
+import { DefaultDocument, GraphBag, SessionRulesetMapBag } from "../components/the-doctor/the-doctor";
+import { ActiveView } from "../events/doctor";
+export class SpecController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    specChanged(event) {
+        const editor = this.doc.editorMap.get(event.detail.id);
+        if (editor && event.detail.id === 'ruleset-editor') {
+            this.doc.ruleController.rulesetManuallyChanged();
+            return;
+        }
+        if (this.doc.docBag) {
+            this.doc.docBag.set(DefaultDocument, event.detail.content);
+        }
+        if (this.doc.autoDiagnose) {
+            clearTimeout(this.doc.bounceId);
+            this.doc.bounceId = window.setTimeout(() => {
+                this.doc.diagnosticController.lintSpec(event.detail.content);
+            }, this.doc.debounceTime);
+        }
+    }
+    specClicked(event) {
+        this.doc.detailsDrawer.close();
+        if (this.doc.selectedEditorTab == "spec") {
+            let problemFound = false;
+            for (let i = 0; i < this.doc.problems?.length; i++) {
+                if (this.doc.problems[i].startLineNumber === event.detail.line) {
+                    this.doc.problemList.lineClicked(event.detail.line, true);
+                    this.doc.controlTabGroup.show(ActiveView.Problems);
+                    if (this.doc.sidebarClosed) {
+                        this.doc.toggleSidebar();
+                    }
+                    problemFound = true;
+                    break;
+                }
+            }
+            // use the graph lookup to find the node, use the graphResponse, if available if not, pull from bag
+            const graph = this.doc.graphBag?.get(GraphBag);
+            if (graph) {
+                if (graph.graphMap && event.detail.line) {
+                    const nodeHash = graph.graphMap[event.detail.line];
+                    if (nodeHash) {
+                        this.doc.modelTree.explorerClicked(nodeHash);
+                        const rendered = this.doc.renderedNodeMap.get(nodeHash);
+                        if (rendered) {
+                            this.doc.renderedNode.node = rendered;
+                        }
+                        if (!problemFound) {
+                            this.doc.viewerPanel.click();
+                        }
+                        const n = this.doc.nodeIdHashMap.get(nodeHash);
+                        if (n) {
+                            this.doc.explorer.activeNode = n;
+                            this.doc.explorer.equalizer.activeNode = n;
+                        }
+                    }
+                }
+            }
+        }
+        if (this.doc.selectedEditorTab == ActiveView.Ruleset) {
+            // check ruleset map for the line number
+            const rulesetMap = this.doc.sessionRulesetMapBag?.get(SessionRulesetMapBag);
+            if (rulesetMap?.rulesMap) {
+                for (let i = 0; i < rulesetMap.rulesMap.length; i++) {
+                    if (rulesetMap.rulesMap[i].line === event.detail.line) {
+                        this.doc.controlTabGroup.show(ActiveView.Ruleset);
+                        if (this.doc.sidebarClosed) {
+                            this.doc.toggleSidebar();
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}

package/dist/controllers/state-controller.d.ts

@@ -0,0 +1,9 @@
+import { TheDoctor } from "../components/the-doctor/the-doctor.js";
+import { RuleFunctionSchema } from "../model/vacuum_rule.js";
+export declare class StateController extends EventTarget {
+    doc: TheDoctor;
+    constructor(doc: TheDoctor);
+    loadState(): void;
+    fetchFunctions(): Promise<string[]>;
+    fetchFunctionSchema(functionId: string): Promise<RuleFunctionSchema>;
+}

package/dist/controllers/state-controller.js

@@ -0,0 +1,279 @@
+import { AllRulesetBag, CustomRulesetBag, DefaultDocument, DefaultRulesetBag, DiagnosticBag, DocumentProblems, FunctionsBag, FunctionsSchemaBag, GraphBag, HowToFixBag, OWASPRulesetBag, PanelStateBag, ReferenceMapBag, RolodexResponseBag, RolodexStateBag, RuleConfigurationBag, SessionRulesetMapBag, SettingsBag } from "../components/the-doctor/the-doctor.js";
+import { ModelService } from "../services/model-service.js";
+import { Problem } from "../model/problem.js";
+import { RulesetService } from "../services/ruleset-service";
+export class StateController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    loadState() {
+        // register a handler for settings bag changes.
+        this.doc.settingsBag?.onAllChanges(this.doc.settingsChanged.bind(this));
+        this.doc.settingsComponent.settingsBag = this.doc.settingsBag;
+        if (this.doc.settingsBag) {
+            this.doc.settingsChanged('', this.doc.settingsBag.get(SettingsBag));
+        }
+        this.doc.settingsComponent.bootstrap();
+        this.doc.rolodexNeedsReset = true;
+        // load the rolodex
+        if (this.doc.rolodexResponseBag) {
+            const response = this.doc.rolodexResponseBag.get(RolodexResponseBag);
+            if (response) {
+                this.doc.rolodexRoot = response.rolodexRoot;
+                this.doc.rolodexTree.isRolodex = true;
+                this.doc.rolodexTree.node = response.rolodexRoot;
+                response.rolodexRoot.treeExpanded = true;
+                this.doc.requestUpdate();
+            }
+        }
+        let skipDocBag = false;
+        const checkRefMap = (key) => {
+            let refMap = this.doc.referenceMapBag?.get(ReferenceMapBag);
+            if (refMap) {
+                // TODO: replace with scehduled task to refresh the reference map
+                setTimeout(() => {
+                    let refs = refMap?.references[key];
+                    if (!refs) {
+                        refs = refMap?.references[""]; // single file
+                    }
+                    if (refs) {
+                        this.doc.references = refs;
+                        this.doc.editor.links = refs;
+                        this.doc.editor.applyLinkDecorations();
+                    }
+                }, 5); // editor has not loaded yet, give it a second to breathe.
+            }
+            else {
+                ModelService.fetchReferenceMap().then((result) => {
+                    this.doc.references = result;
+                    this.doc.editor.links = result;
+                    this.doc.editor.applyLinkDecorations();
+                }).catch(() => {
+                    this.doc.editor.clearDecorations();
+                    this.doc.editor.clearAllMarkers();
+                });
+            }
+        };
+        if (this.doc.rolodexStateBag) {
+            const state = this.doc.rolodexStateBag.get(RolodexStateBag);
+            if (state) {
+                this.doc.rolodexActivePath = state.activePath;
+                this.doc.rolodexActiveHash = state.activeHash;
+                // load the root.
+                if (state.rootHash) {
+                    this.doc.rolodexTree.pendingNavigationHash = state.rootHash;
+                }
+                if (state.rootPath) {
+                    this.doc.rolodexRootPath = state.rootPath;
+                    if (state.activePath) {
+                        checkRefMap(state.activePath);
+                    }
+                    // ensure the session has a root selected
+                    ModelService.selectRootPath(state.rootPath).then(() => {
+                        // nothing to do.
+                    }).catch((e) => {
+                        console.error('could not select the root path on boot bro', e);
+                    });
+                }
+                if (state.rootHash)
+                    this.doc.rolodexRootHash = state.rootHash;
+                if (state.activePath) {
+                    this.doc.rolodexTree.pendingNavigationPath = state.activePath;
+                    this.doc.rolodexTree.requestUpdate();
+                }
+                if (state.activeNode) {
+                    // load the content of the active node into the editor
+                    if (state.activeLanguage) {
+                        this.doc.editor.switchLanguage(state.activeLanguage);
+                    }
+                    this.doc.editor.setValue(state.activeNode.instance, true);
+                    skipDocBag = true;
+                }
+            }
+            else {
+                this.doc.rolodexActivePath = "root";
+                // refresh the refmap.
+                checkRefMap(this.doc.rolodexActivePath);
+            }
+        }
+        if (this.doc.docBag && !skipDocBag) {
+            const doc = this.doc.docBag.get(DefaultDocument);
+            if (doc) {
+                this.doc.editor.setValue(doc, true);
+            }
+        }
+        this.doc.problemBag = this.doc.bagManager.getBag(DocumentProblems);
+        if (this.doc.problemBag) {
+            const markers = this.doc.problemBag.get(DocumentProblems);
+            if (markers) {
+                this.doc.problems = markers;
+                for (let i = 0; i < markers.length; i++) {
+                    markers[i] = Problem.reconstruct(markers[i]);
+                }
+                this.doc.rolodexController.buildRolodexResultMap(markers);
+                if (this.doc.rolodexProblemMap.size > 0 && this.doc.rolodexProblemMap.has(this.doc.rolodexActivePath)) {
+                    const probs = this.doc.rolodexProblemMap.get(this.doc.rolodexActivePath);
+                    if (probs) {
+                        this.doc.editor.setMarkers(probs);
+                    }
+                }
+                this.doc.problemList.problems = markers;
+                this.doc.problemsOverview.problems = this.doc.problemList.problemItems;
+            }
+        }
+        this.doc.howToFixBag = this.doc.bagManager.getBag(HowToFixBag);
+        this.doc.diagnosticBag = this.doc.bagManager.getBag(DiagnosticBag);
+        if (this.doc.diagnosticBag) {
+            const stats = this.doc.diagnosticBag.get(DiagnosticBag);
+            if (stats) {
+                this.doc.problemsOverview.statistics = stats;
+            }
+        }
+        // extract graph
+        if (this.doc.graphBag) {
+            const graph = this.doc.graphBag.get(GraphBag);
+            if (graph) {
+                this.doc.modelController.extractGraph(graph);
+            }
+        }
+        // extract panel state
+        if (this.doc.panelStateBag) {
+            const panelState = this.doc.panelStateBag.get(PanelStateBag);
+            if (panelState && panelState.explorerPanel) {
+                this.doc.splitPanelExplorer.position = panelState.explorerPanel;
+            }
+            if (panelState && panelState.rolodexPanel) {
+                if (this.doc.splitPanelRolodex) {
+                    this.doc.splitPanelRolodex.position = panelState.rolodexPanel;
+                }
+                this.doc.rolodexDividerPosition = panelState.rolodexPanel;
+            }
+            if (panelState && panelState.inspectorPanel) {
+                this.doc.splitPanelInspector.position = panelState.inspectorPanel;
+            }
+        }
+        if (!this.doc.rolodexRoot) {
+            // this.importDisabled = false;
+        }
+        else {
+            // this.importDisabled = true;
+        }
+        // extract rulesets from bags
+        const promises = [];
+        this.doc.defaultRulesetBag = this.doc.bagManager.getBag(DefaultRulesetBag);
+        if (this.doc.defaultRulesetBag) {
+            const ruleset = this.doc.defaultRulesetBag.get(DefaultRulesetBag);
+            if (ruleset) {
+                this.doc.defaultRuleset = ruleset;
+            }
+            else {
+                promises.push(this.doc.ruleController.fetchDefaultRuleset());
+            }
+        }
+        // OWASP ruleset
+        this.doc.OWASPRulesetBag = this.doc.bagManager.getBag(OWASPRulesetBag);
+        if (this.doc.OWASPRulesetBag) {
+            const ruleset = this.doc.OWASPRulesetBag.get(OWASPRulesetBag);
+            if (ruleset) {
+                this.doc.OWASPRuleset = ruleset;
+            }
+            else {
+                promises.push(this.doc.ruleController.fetchOWASPRuleset());
+            }
+        }
+        // All ruleset
+        this.doc.allRulesetBag = this.doc.bagManager.getBag(AllRulesetBag);
+        if (this.doc.allRulesetBag) {
+            const ruleset = this.doc.allRulesetBag.get(AllRulesetBag);
+            if (ruleset) {
+                this.doc.allRuleset = ruleset;
+            }
+            else {
+                promises.push(this.doc.ruleController.fetchAllRuleset());
+            }
+        }
+        // functions
+        this.doc.functionsBag = this.doc.bagManager.getBag(FunctionsBag);
+        this.doc.functionSchemaBag = this.doc.bagManager.getBag(FunctionsSchemaBag);
+        if (this.doc.functionsBag) {
+            const functions = this.doc.functionsBag.get(FunctionsBag);
+            if (functions) {
+                this.doc.functions = functions;
+            }
+            else {
+                promises.push(this.fetchFunctions());
+            }
+        }
+        // custom ruleset
+        this.doc.customRulesetBag = this.doc.bagManager.getBag(CustomRulesetBag);
+        if (this.doc.customRulesetBag) {
+            const ruleset = this.doc.customRulesetBag.get(CustomRulesetBag);
+            if (ruleset) {
+                this.doc.customRuleset = ruleset;
+            }
+        }
+        // create rule configuration bag
+        this.doc.ruleConfigBag = this.doc.bagManager.getBag(RuleConfigurationBag);
+        // create rule configuration bag
+        this.doc.sessionRulesetMapBag = this.doc.bagManager.getBag(SessionRulesetMapBag);
+        // fire off all network requests, then configure the ruleset management.
+        Promise.all(promises).then(() => {
+            // configure rule management
+            this.doc.manageRuleset.defaultRuleset = this.doc.defaultRuleset;
+            this.doc.manageRuleset.owaspRuleset = this.doc.OWASPRuleset;
+            this.doc.manageRuleset.allRuleset = this.doc.allRuleset;
+            this.doc.manageRuleset.functions = this.doc.functions;
+            const config = this.doc.ruleConfigBag?.get(RuleConfigurationBag);
+            if (config) {
+                this.doc.manageRuleset.rulesetConfig = config;
+            }
+            else {
+                this.doc.manageRuleset.rulesetConfig = { ruleMapping: new Map(), allRulesSwitch: true };
+            }
+            setTimeout(() => {
+                this.doc.manageRuleset.buildRulesets();
+                if (this.doc.customRuleset && this.doc.customRuleset.rules.size > 0) {
+                    this.doc.manageRuleset.customRuleset = this.doc.customRuleset;
+                }
+                this.doc.ruleController.fetchSessionRulesetAsYaml().then((result) => {
+                    this.doc.rulesetEditor?.setValue(result, true);
+                    this.doc.ruleController.fetchRulesetMap();
+                }).catch((e) => {
+                    this.doc.platformUnavailable(e);
+                });
+            }, 50);
+        });
+        // refresh state for how to fix.
+        this.doc.docsController.fetchDocs();
+    }
+    async fetchFunctions() {
+        return new Promise(async (resolve) => {
+            RulesetService.getFunctions().then((result) => {
+                this.doc.functions = result;
+                this.doc.functionsBag?.set(FunctionsBag, result);
+                // extract schemas for each function
+                const promises = [];
+                result.forEach((functionId) => {
+                    promises.push(this.fetchFunctionSchema(functionId));
+                });
+                Promise.all(promises).then(() => {
+                    resolve(result);
+                });
+            });
+        });
+    }
+    async fetchFunctionSchema(functionId) {
+        return new Promise(async (resolve) => {
+            RulesetService.getFunctionSchema(functionId).then((result) => {
+                let m = this.doc.functionSchemaBag?.get(FunctionsSchemaBag);
+                if (!m) {
+                    m = new Map();
+                }
+                m.set(functionId, result);
+                this.doc.functionSchemaBag?.set(FunctionsSchemaBag, m);
+                resolve(result);
+            });
+        });
+    }
+}