@oneuptime/common 12.0.7 → 12.0.9

package/build/dist/UI/Components/Workflow/GraphLint.js

@@ -0,0 +1,425 @@
+/*
+ * Static checks over a workflow graph, run in the builder as the user edits.
+ *
+ * Every rule here corresponds to a way the runner (App/FeatureSet/Workflow/
+ * Services/RunWorkflow.ts) either throws at run time or — worse — carries on
+ * quietly with the wrong value. The point is to move those failures from "3am,
+ * in a log blob, after the trigger already fired" to "in the editor, before
+ * you save".
+ *
+ * Rules only fire on things that are knowable from the graph alone. Anything
+ * needing a network round trip (does this workflow variable exist?) is checked
+ * for shape but not for existence, because a false positive here puts a red
+ * badge on a workflow that runs perfectly.
+ */
+import { ComponentInputType, ComponentType, NodeType, isJSON5ToleratedInputType, } from "../../../Types/Workflow/Component";
+import { ReferenceRootType, TemplateExpressionKind, checkJSONSyntax, looksLikeReferencePath, parseReferencePath, parseTemplateExpressions, } from "../../../Types/Workflow/TemplateSyntax";
+export var WorkflowLintSeverity;
+(function (WorkflowLintSeverity) {
+    /** The workflow will fail, or silently do the wrong thing, as written. */
+    WorkflowLintSeverity["Error"] = "Error";
+    /** Suspicious but survivable — e.g. a step that can never be reached. */
+    WorkflowLintSeverity["Warning"] = "Warning";
+})(WorkflowLintSeverity || (WorkflowLintSeverity = {}));
+export var WorkflowLintRule;
+(function (WorkflowLintRule) {
+    WorkflowLintRule["MissingRequiredArgument"] = "MissingRequiredArgument";
+    WorkflowLintRule["InvalidJSON"] = "InvalidJSON";
+    WorkflowLintRule["ReferenceHasWhitespace"] = "ReferenceHasWhitespace";
+    WorkflowLintRule["UnknownReferenceRoot"] = "UnknownReferenceRoot";
+    WorkflowLintRule["UnknownReferencedComponent"] = "UnknownReferencedComponent";
+    WorkflowLintRule["UnknownReferencedReturnValue"] = "UnknownReferencedReturnValue";
+    WorkflowLintRule["SelfReference"] = "SelfReference";
+    WorkflowLintRule["ForwardReference"] = "ForwardReference";
+    WorkflowLintRule["ReferenceToUnreachableComponent"] = "ReferenceToUnreachableComponent";
+    WorkflowLintRule["DuplicateComponentId"] = "DuplicateComponentId";
+    WorkflowLintRule["ComponentIdContainsDot"] = "ComponentIdContainsDot";
+    WorkflowLintRule["UnreachableComponent"] = "UnreachableComponent";
+    WorkflowLintRule["NoTrigger"] = "NoTrigger";
+})(WorkflowLintRule || (WorkflowLintRule = {}));
+/*
+ * Argument types the builder stores as a JSON document in a code editor. A
+ * malformed one throws in RunWorkflow.getComponentArguments (for JSON / Query /
+ * Select) or in the component itself (JSONFunctions.parse in
+ * CreateOneBaseModel, ApiComponentUtils.sanitizeArgs, and friends), so all of
+ * them are worth checking up front.
+ */
+const JSON_DOCUMENT_INPUT_TYPES = [
+    ComponentInputType.JSON,
+    ComponentInputType.JSONArray,
+    ComponentInputType.Query,
+    ComponentInputType.Select,
+    ComponentInputType.BaseModel,
+    ComponentInputType.BaseModelArray,
+    ComponentInputType.StringDictionary,
+];
+/*
+ * `false` and `0` are values a builder deliberately set — only absence and the
+ * empty box count as missing. An empty object/array counts as missing too: the
+ * Dictionary editor writes `{}` for a field nobody filled in.
+ *
+ * For a JSON-document argument the value arrives as *text*, so the literal
+ * "{}" has to be recognised as the same emptiness. It reads as a filled-in
+ * field otherwise, and on Delete Many an empty query is not a harmless no-op:
+ * it matches every record in the project and the component deletes the first
+ * ten of them. A required argument holding "{}" should be reported, not run.
+ */
+export const isEmptyArgumentValue = (value, type) => {
+    if (value === undefined || value === null) {
+        return true;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed === "") {
+            return true;
+        }
+        if (type && JSON_DOCUMENT_INPUT_TYPES.includes(type)) {
+            /*
+             * Only a literal empty document counts. Anything that fails to parse is
+             * left alone — it is reported as invalid JSON a few lines further down,
+             * which is a better message than "this is required".
+             */
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (Array.isArray(parsed)) {
+                    return parsed.length === 0;
+                }
+                if (parsed && typeof parsed === "object") {
+                    return Object.keys(parsed).length === 0;
+                }
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === "object") {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+};
+const isRealNode = (node) => {
+    return Boolean(node.data &&
+        node.data.nodeType !== NodeType.PlaceholderNode &&
+        node.data.metadata);
+};
+/** Every node id reachable by following edges forward from `startNodeIds`. */
+const buildReachableSet = (startNodeIds, adjacency) => {
+    const reachable = new Set();
+    const queue = [...startNodeIds];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (reachable.has(current)) {
+            continue;
+        }
+        reachable.add(current);
+        for (const next of adjacency[current] || []) {
+            if (!reachable.has(next)) {
+                queue.push(next);
+            }
+        }
+    }
+    return reachable;
+};
+/*
+ * A reference can hide anywhere a string can: the Dictionary editor stores an
+ * object whose values are strings, and imported graphs can hold arrays. Walk
+ * the whole value so {{...}} inside a header value is linted too.
+ */
+const collectArgumentStrings = (value) => {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => {
+            return collectArgumentStrings(item);
+        });
+    }
+    if (value && typeof value === "object") {
+        return Object.values(value).flatMap((item) => {
+            return collectArgumentStrings(item);
+        });
+    }
+    return [];
+};
+/**
+ * Check a workflow graph and report everything wrong with it.
+ */
+export const lintWorkflowGraph = (graph) => {
+    var _a;
+    const issues = [];
+    const nodes = (graph.nodes || []).filter(isRealNode);
+    const edges = graph.edges || [];
+    const addIssue = (issue) => {
+        issues.push(issue);
+    };
+    /* ---- indexes ---------------------------------------------------------- */
+    // The runner keys its storage map on node.data.id, not the react-flow id.
+    const nodesByComponentId = {};
+    const componentIdCounts = {};
+    for (const node of nodes) {
+        const componentId = node.data.id;
+        if (!componentId) {
+            continue;
+        }
+        componentIdCounts[componentId] = (componentIdCounts[componentId] || 0) + 1;
+        if (!nodesByComponentId[componentId]) {
+            nodesByComponentId[componentId] = node;
+        }
+    }
+    const adjacency = {};
+    for (const edge of edges) {
+        if (!adjacency[edge.source]) {
+            adjacency[edge.source] = [];
+        }
+        (_a = adjacency[edge.source]) === null || _a === void 0 ? void 0 : _a.push(edge.target);
+    }
+    const triggerNodes = nodes.filter((node) => {
+        return node.data.componentType === ComponentType.Trigger;
+    });
+    const reachableFromTrigger = buildReachableSet(triggerNodes.map((node) => {
+        return node.id;
+    }), adjacency);
+    /*
+     * Strict descendants of a node, computed at most once per node — the
+     * reference rules ask for this per argument, and recomputing a traversal
+     * inside that loop makes linting quadratic on graphs that are already wide.
+     */
+    const descendantCache = {};
+    const getDescendants = (nodeId) => {
+        let descendants = descendantCache[nodeId];
+        if (!descendants) {
+            descendants = buildReachableSet(adjacency[nodeId] || [], adjacency);
+            descendantCache[nodeId] = descendants;
+        }
+        return descendants;
+    };
+    /* ---- graph-wide rules -------------------------------------------------- */
+    if (nodes.length > 0 && triggerNodes.length === 0) {
+        addIssue({
+            rule: WorkflowLintRule.NoTrigger,
+            severity: WorkflowLintSeverity.Error,
+            nodeId: null,
+            componentId: null,
+            argumentId: null,
+            message: "This workflow has no trigger, so it can never start. Add a trigger and connect it to the first step.",
+        });
+    }
+    /* ---- per-node rules ---------------------------------------------------- */
+    for (const node of nodes) {
+        const data = node.data;
+        const componentId = data.id;
+        const argumentValues = data.arguments || {};
+        const addNodeIssue = (params) => {
+            addIssue({
+                rule: params.rule,
+                severity: params.severity,
+                nodeId: node.id,
+                componentId: componentId || null,
+                argumentId: params.argumentId || null,
+                message: params.message,
+            });
+        };
+        // -- identity ---------------------------------------------------------
+        if (componentId && (componentIdCounts[componentId] || 0) > 1) {
+            addNodeIssue({
+                rule: WorkflowLintRule.DuplicateComponentId,
+                severity: WorkflowLintSeverity.Error,
+                message: `More than one step has the id "${componentId}". Ids must be unique — otherwise the steps overwrite each other's results and any reference to "${componentId}" is ambiguous.`,
+            });
+        }
+        if (componentId && componentId.includes(".")) {
+            addNodeIssue({
+                rule: WorkflowLintRule.ComponentIdContainsDot,
+                severity: WorkflowLintSeverity.Error,
+                message: `The id "${componentId}" contains a dot. References are split on dots, so no other step can read this one's results. Use dashes instead.`,
+            });
+        }
+        // -- reachability ------------------------------------------------------
+        if (data.componentType !== ComponentType.Trigger &&
+            triggerNodes.length > 0 &&
+            !reachableFromTrigger.has(node.id)) {
+            addNodeIssue({
+                rule: WorkflowLintRule.UnreachableComponent,
+                severity: WorkflowLintSeverity.Warning,
+                message: "Nothing connects to this step from the trigger, so it will never run.",
+            });
+        }
+        // -- arguments ---------------------------------------------------------
+        const argumentMetadata = data.metadata.arguments || [];
+        for (const argument of argumentMetadata) {
+            const value = argumentValues[argument.id];
+            if (argument.required && isEmptyArgumentValue(value, argument.type)) {
+                addNodeIssue({
+                    rule: WorkflowLintRule.MissingRequiredArgument,
+                    severity: WorkflowLintSeverity.Error,
+                    argumentId: argument.id,
+                    message: `"${argument.name}" is required but empty.`,
+                });
+                continue;
+            }
+            if (isEmptyArgumentValue(value, argument.type)) {
+                continue;
+            }
+            if (JSON_DOCUMENT_INPUT_TYPES.includes(argument.type)) {
+                const jsonCheck = checkJSONSyntax(value, {
+                    allowJSON5: isJSON5ToleratedInputType(argument.type),
+                });
+                if (!jsonCheck.isValid) {
+                    addNodeIssue({
+                        rule: WorkflowLintRule.InvalidJSON,
+                        severity: WorkflowLintSeverity.Error,
+                        argumentId: argument.id,
+                        message: `"${argument.name}" is not valid JSON. ${jsonCheck.errorMessage}`,
+                    });
+                }
+            }
+            // -- references ------------------------------------------------------
+            for (const text of collectArgumentStrings(value)) {
+                const expressions = parseTemplateExpressions(text);
+                for (const expression of expressions) {
+                    if (expression.kind !== TemplateExpressionKind.Reference) {
+                        continue;
+                    }
+                    /*
+                     * Inside a loop, VMAPI resolves against the current array element
+                     * before the storage map, so a bare {{status}} is correct there and
+                     * cannot be checked from here.
+                     */
+                    if (expression.isInsideEachBlock) {
+                        continue;
+                    }
+                    /*
+                     * At the top level the runtime looks the path up exactly as written
+                     * (VMAPI.replaceValueInPlace passes the raw capture to deepFind), so
+                     * a stray space makes the reference resolve to nothing and the braces
+                     * are shipped as literal text. Nothing about the rendered workflow
+                     * hints at it, which makes this worth its own message rather than
+                     * folding it into "unknown reference".
+                     */
+                    /*
+                     * Every argument is templated, including the JavaScript component's
+                     * source, and JavaScript can legitimately produce a {{...}} match on
+                     * one line. Only complain about captures that were plausibly meant
+                     * to be references.
+                     */
+                    if (!looksLikeReferencePath(expression.innerRaw)) {
+                        continue;
+                    }
+                    if (expression.innerRaw !== expression.inner) {
+                        addNodeIssue({
+                            rule: WorkflowLintRule.ReferenceHasWhitespace,
+                            severity: WorkflowLintSeverity.Error,
+                            argumentId: argument.id,
+                            message: `"${argument.name}" contains ${expression.raw}, which has a space inside the braces. Spaces are not trimmed here, so this resolves to nothing — write it as {{${expression.inner}}}.`,
+                        });
+                        continue;
+                    }
+                    const parsed = parseReferencePath(expression.inner);
+                    if (parsed.rootType === ReferenceRootType.Unknown) {
+                        addNodeIssue({
+                            rule: WorkflowLintRule.UnknownReferenceRoot,
+                            severity: WorkflowLintSeverity.Error,
+                            argumentId: argument.id,
+                            message: `"${argument.name}" refers to ${expression.raw}, but ${parsed.reason}. Nothing will be substituted and the text will be sent as-is.`,
+                        });
+                        continue;
+                    }
+                    if (parsed.rootType !== ReferenceRootType.ComponentReturnValue) {
+                        // A variable reference — well-formed. Existence needs the API.
+                        continue;
+                    }
+                    const referencedComponentId = parsed.componentId;
+                    const referencedNode = nodesByComponentId[referencedComponentId];
+                    if (!referencedNode) {
+                        addNodeIssue({
+                            rule: WorkflowLintRule.UnknownReferencedComponent,
+                            severity: WorkflowLintSeverity.Error,
+                            argumentId: argument.id,
+                            message: `"${argument.name}" refers to a step called "${referencedComponentId}", but no step in this workflow has that id.`,
+                        });
+                        continue;
+                    }
+                    const returnValueId = parsed.returnValueId;
+                    const returnValues = referencedNode.data.metadata.returnValues || [];
+                    const hasReturnValue = returnValues.some((returnValue) => {
+                        return returnValue.id === returnValueId;
+                    });
+                    if (!hasReturnValue) {
+                        addNodeIssue({
+                            rule: WorkflowLintRule.UnknownReferencedReturnValue,
+                            severity: WorkflowLintSeverity.Error,
+                            argumentId: argument.id,
+                            message: `"${argument.name}" reads "${returnValueId}" from step "${referencedComponentId}", but that step does not return anything by that name.`,
+                        });
+                        continue;
+                    }
+                    if (referencedNode.id === node.id) {
+                        addNodeIssue({
+                            rule: WorkflowLintRule.SelfReference,
+                            severity: WorkflowLintSeverity.Error,
+                            argumentId: argument.id,
+                            message: `"${argument.name}" refers to this step's own results, which do not exist yet while its settings are being read.`,
+                        });
+                        continue;
+                    }
+                    /*
+                     * A step that is downstream of this one has definitively not run
+                     * when this step's arguments are resolved, so the reference is
+                     * always empty. (The converse is not true — the runner's queue is
+                     * FIFO across branches, so a step on a parallel branch may well have
+                     * run. Only the unambiguous direction is reported.)
+                     */
+                    if (getDescendants(node.id).has(referencedNode.id)) {
+                        addNodeIssue({
+                            rule: WorkflowLintRule.ForwardReference,
+                            severity: WorkflowLintSeverity.Error,
+                            argumentId: argument.id,
+                            message: `"${argument.name}" reads results from "${referencedComponentId}", but that step runs after this one, so it has no results yet.`,
+                        });
+                        continue;
+                    }
+                    if (triggerNodes.length > 0 &&
+                        !reachableFromTrigger.has(referencedNode.id)) {
+                        addNodeIssue({
+                            rule: WorkflowLintRule.ReferenceToUnreachableComponent,
+                            severity: WorkflowLintSeverity.Warning,
+                            argumentId: argument.id,
+                            message: `"${argument.name}" reads results from "${referencedComponentId}", which is not connected to the trigger and so never runs.`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /* ---- roll up ----------------------------------------------------------- */
+    const errorsByNodeId = {};
+    let errorCount = 0;
+    let warningCount = 0;
+    for (const issue of issues) {
+        if (issue.severity === WorkflowLintSeverity.Error) {
+            errorCount++;
+        }
+        else {
+            warningCount++;
+        }
+        if (!issue.nodeId) {
+            continue;
+        }
+        errorsByNodeId[issue.nodeId] = errorsByNodeId[issue.nodeId]
+            ? `${errorsByNodeId[issue.nodeId]}\n${issue.message}`
+            : issue.message;
+    }
+    return {
+        issues: issues,
+        errorsByNodeId: errorsByNodeId,
+        errorCount: errorCount,
+        warningCount: warningCount,
+    };
+};
+export default lintWorkflowGraph;
+//# sourceMappingURL=GraphLint.js.map

package/build/dist/UI/Components/Workflow/GraphLint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphLint.js","sourceRoot":"","sources":["../../../../../UI/Components/Workflow/GraphLint.ts"],"names":[],"mappings":"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"}

package/build/dist/UI/Components/Workflow/GraphLintSummary.js

@@ -0,0 +1,231 @@
+/*
+ * How the builder presents what GraphLint found.
+ *
+ * GraphLint reports one issue per problem, which is right for a checker and
+ * wrong for a panel: a step with three empty required fields produces three
+ * issues, and rendering them flat gives three cards that happen to repeat the
+ * same step id. Everything here is about arranging that list instead —
+ * counting it, naming the step each issue belongs to, and folding one step's
+ * issues into a single group the builder can act on.
+ *
+ * The other half of the panel — taking the builder to the step a group is
+ * about — needs to look a node up by id, so that lives here too.
+ *
+ * Kept apart from the components that render it so all of it is testable
+ * without a DOM.
+ */
+import { NodeType } from "../../../Types/Workflow/Component";
+import { WorkflowLintSeverity } from "./GraphLint";
+/**
+ * What the graph looks like overall. Drives one colour choice in the toolbar,
+ * so it is deliberately three states rather than a count.
+ */
+export var WorkflowLintTone;
+(function (WorkflowLintTone) {
+    /** Nothing to report. */
+    WorkflowLintTone["Clean"] = "Clean";
+    /** Only warnings — the workflow runs, but probably not as intended. */
+    WorkflowLintTone["Warning"] = "Warning";
+    /** At least one error — the workflow fails, or does the wrong thing. */
+    WorkflowLintTone["Error"] = "Error";
+})(WorkflowLintTone || (WorkflowLintTone = {}));
+/** Issues about the graph itself rather than any one step. */
+export const WORKFLOW_ISSUE_GRAPH_GROUP_KEY = "__workflow__";
+export const WORKFLOW_ISSUE_GRAPH_GROUP_TITLE = "This workflow";
+/** A step that has issues but no title and no id to show for itself. */
+export const WORKFLOW_ISSUE_UNTITLED_STEP_TITLE = "Untitled step";
+const pluralise = (count, singular) => {
+    return `${count} ${singular}${count === 1 ? "" : "s"}`;
+};
+/**
+ * "1 error, 2 warnings" — empty when there is nothing to report.
+ *
+ * Errors are called errors rather than "problems" because the panel these
+ * counts label is titled "Problems", and having "problems" also mean
+ * specifically-the-errors inside it left the two counts reading as subsets of
+ * each other.
+ */
+export const getWorkflowLintCountText = (counts) => {
+    const parts = [];
+    if (counts.errorCount > 0) {
+        parts.push(pluralise(counts.errorCount, "error"));
+    }
+    if (counts.warningCount > 0) {
+        parts.push(pluralise(counts.warningCount, "warning"));
+    }
+    return parts.join(", ");
+};
+export const getWorkflowLintTone = (counts) => {
+    if (counts.errorCount > 0) {
+        return WorkflowLintTone.Error;
+    }
+    if (counts.warningCount > 0) {
+        return WorkflowLintTone.Warning;
+    }
+    return WorkflowLintTone.Clean;
+};
+/** The word for a severity — the panel says it out loud rather than only colouring it. */
+export const getWorkflowLintSeverityLabel = (severity) => {
+    return severity === WorkflowLintSeverity.Error ? "Error" : "Warning";
+};
+/**
+ * Step titles keyed by react-flow node id, so the issues panel can name a step
+ * the way the canvas does rather than only by the id the builder typed.
+ */
+export const buildStepTitlesByNodeId = (nodes) => {
+    var _a, _b;
+    const titles = {};
+    for (const node of nodes || []) {
+        if (!node || !node.id) {
+            continue;
+        }
+        const title = (_b = (_a = node.data) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.title;
+        if (title && title.trim()) {
+            titles[node.id] = title.trim();
+        }
+    }
+    return titles;
+};
+/**
+ * The node a "go to this step" request means, or null when there is nothing to
+ * open.
+ *
+ * A request can name a node that has since been deleted — the panel is a
+ * snapshot of what the checks last said, and the graph carries on being
+ * edited underneath it. A placeholder is not a step either: it is the empty
+ * slot where a trigger goes, and it has no settings.
+ */
+export const findStepNodeToOpen = (params) => {
+    var _a;
+    if (!params.nodeId) {
+        return null;
+    }
+    const node = (params.nodes || []).find((node) => {
+        return node && node.id === params.nodeId;
+    });
+    if (!node || ((_a = node.data) === null || _a === void 0 ? void 0 : _a.nodeType) === NodeType.PlaceholderNode) {
+        return null;
+    }
+    return node;
+};
+const getGroupKey = (issue) => {
+    if (issue.nodeId) {
+        return `node:${issue.nodeId}`;
+    }
+    /*
+     * A graph-wide issue has no node. Anything that somehow names a step without
+     * naming its node still groups with that step rather than with the graph.
+     */
+    if (issue.componentId) {
+        return `component:${issue.componentId}`;
+    }
+    return WORKFLOW_ISSUE_GRAPH_GROUP_KEY;
+};
+const getGroupTitle = (params) => {
+    const { issue, stepTitlesByNodeId } = params;
+    if (!issue.nodeId && !issue.componentId) {
+        return WORKFLOW_ISSUE_GRAPH_GROUP_TITLE;
+    }
+    const titleFromGraph = issue.nodeId
+        ? stepTitlesByNodeId[issue.nodeId]
+        : undefined;
+    return (titleFromGraph || issue.componentId || WORKFLOW_ISSUE_UNTITLED_STEP_TITLE);
+};
+/**
+ * One group per step, errors first, and the graph's own issues at the top.
+ *
+ * Identical messages inside a group are dropped: two rules can land on the
+ * same wording for the same step, and a panel that says the same sentence
+ * twice reads as a rendering bug rather than as two findings.
+ */
+export const groupWorkflowLintIssues = (params) => {
+    const stepTitlesByNodeId = params.stepTitlesByNodeId || {};
+    const groupsByKey = {};
+    const orderedKeys = [];
+    const seenMessagesByKey = {};
+    for (const issue of params.issues || []) {
+        if (!issue) {
+            continue;
+        }
+        const key = getGroupKey(issue);
+        let group = groupsByKey[key];
+        if (!group) {
+            group = {
+                key: key,
+                nodeId: issue.nodeId,
+                componentId: issue.componentId,
+                title: getGroupTitle({
+                    issue: issue,
+                    stepTitlesByNodeId: stepTitlesByNodeId,
+                }),
+                issues: [],
+                errorCount: 0,
+                warningCount: 0,
+            };
+            groupsByKey[key] = group;
+            seenMessagesByKey[key] = new Set();
+            orderedKeys.push(key);
+        }
+        const seenMessages = seenMessagesByKey[key];
+        const messageKey = `${issue.severity}|${issue.message}`;
+        if (seenMessages.has(messageKey)) {
+            continue;
+        }
+        seenMessages.add(messageKey);
+        group.issues.push(issue);
+        if (issue.severity === WorkflowLintSeverity.Error) {
+            group.errorCount++;
+        }
+        else {
+            group.warningCount++;
+        }
+    }
+    const groups = orderedKeys
+        .map((key, index) => {
+        const group = groupsByKey[key];
+        /*
+         * Errors first inside a group: they are what stops the workflow, and a
+         * warning read first sets the wrong expectation about the rest.
+         * `index` keeps the sort stable across engines that do not guarantee it.
+         */
+        group.issues = group.issues
+            .map((issue, issueIndex) => {
+            return { issue: issue, issueIndex: issueIndex };
+        })
+            .sort((a, b) => {
+            const aIsError = a.issue.severity === WorkflowLintSeverity.Error ? 0 : 1;
+            const bIsError = b.issue.severity === WorkflowLintSeverity.Error ? 0 : 1;
+            if (aIsError !== bIsError) {
+                return aIsError - bIsError;
+            }
+            return a.issueIndex - b.issueIndex;
+        })
+            .map((entry) => {
+            return entry.issue;
+        });
+        return { group: group, index: index };
+    })
+        .sort((a, b) => {
+        /*
+         * "This workflow has no trigger" is about the thing every step hangs
+         * off, so the graph's own issues lead regardless of what else is wrong.
+         */
+        const aIsGraph = a.group.key === WORKFLOW_ISSUE_GRAPH_GROUP_KEY ? 0 : 1;
+        const bIsGraph = b.group.key === WORKFLOW_ISSUE_GRAPH_GROUP_KEY ? 0 : 1;
+        if (aIsGraph !== bIsGraph) {
+            return aIsGraph - bIsGraph;
+        }
+        const aHasErrors = a.group.errorCount > 0 ? 0 : 1;
+        const bHasErrors = b.group.errorCount > 0 ? 0 : 1;
+        if (aHasErrors !== bHasErrors) {
+            return aHasErrors - bHasErrors;
+        }
+        return a.index - b.index;
+    })
+        .map((entry) => {
+        return entry.group;
+    });
+    return groups;
+};
+export default groupWorkflowLintIssues;
+//# sourceMappingURL=GraphLintSummary.js.map