AF-280 enable type checking on build

Author: mehaase

.github/workflows/build.yml

@@ -68,9 +68,7 @@ jobs:
         run: npm ci
       - name: Build
         working-directory: ./src/attack_flow_builder/
-        # Temporarily disable type checking
-        # run: npm run build
-        run: npm run build-only
+        run: npm run build
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:

src/attack_flow_builder/package.json

@@ -10,7 +10,6 @@
     "preview": "vite preview",
     "test:unit": "vitest run",
     "test:watch": "vitest",
-    "build-only": "vite build",
     "type-check": "vue-tsc --build",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",

src/attack_flow_builder/src/assets/configuration/AttackFlowPublisher/AttackFlowPublisher.ts

@@ -6,9 +6,10 @@ import {
     EnumProperty, ListProperty, Property, SemanticAnalyzer,
     SemanticGraphNode, StringProperty
 } from "@OpenChart/DiagramModel";
-import type { GraphExport } from "@OpenChart/DiagramModel";
+import type { GraphExport, JsonValue } from "@OpenChart/DiagramModel";
 import type { FilePublisher } from "@/assets/scripts/Application";
 import Enums from "../AttackFlowTemplates/MitreAttack";
+import type { Prop } from "vue";
 
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -192,17 +193,19 @@ class AttackFlowPublisher implements FilePublisher {
         for (let [key, prop] of property.value) {
             switch (key) {
                 case "ttp":
-                    const json = prop.toJson();
-                    if (json.tactic) {
-                        node["tactic_id"] = json.tactic;
-                        if (json.tactic in Enums.stixIds) {
-                            node["tactic_ref"] = Enums.stixIds[json.tactic];
+                    const json = prop.toJson() as { [x: string]: JsonValue };
+                    const tactic = json?.tactic as null | string;
+                    if (tactic) {
+                        node["tactic_id"] = tactic;
+                        if (tactic in Enums.stixIds) {
+                            node["tactic_ref"] = Enums.stixIds[tactic as keyof typeof Enums.stixIds];
                         }
                     }
-                    if (json.technique) {
-                        node["technique_id"] = json.technique;
-                        if (json.technique in Enums.stixIds) {
-                            node["technique_ref"] = Enums.stixIds[json.technique];
+                    const technique = json?.technique as null | string;
+                    if (technique) {
+                        node["technique_id"] = technique;
+                        if (technique in Enums.stixIds) {
+                            node["technique_ref"] = Enums.stixIds[technique as keyof typeof Enums.stixIds];
                         }
                     }
                     break;
@@ -324,7 +327,14 @@ class AttackFlowPublisher implements FilePublisher {
                     }
                 }
                 if (hashList.length > 0) {
-                    const hashes = hashList.map(hash => [hash.hash_type, hash.hash_value]); // Drop the property labels
+                    const hashes = hashList.map(hash => {
+                        const hashJson = hash as { [x: string]: JsonValue };
+                        if (hashJson) {
+                            return [hashJson.hash_type, hashJson.hash_value];
+                        } else {
+                            return [];
+                        }
+                    }); // Drop the property labels
                     node[key] = Object.fromEntries(hashes);
                 }
         }
@@ -728,10 +738,13 @@ class AttackFlowPublisher implements FilePublisher {
                         if (!(ref instanceof DictionaryProperty)) {
                             throw new Error(`'${key}' is improperly defined.`);
                         }
-                        const entries = Object
-                            .entries(this.toStixValue(ref))
-                            .filter(o => o[1] !== null);
-                        extRefs.push(Object.fromEntries(entries));
+                        const stixVal = this.toStixValue(ref);
+                        if (stixVal) {
+                            const entries = Object
+                                .entries(stixVal)
+                                .filter(o => o[1] !== null);
+                            extRefs.push(Object.fromEntries(entries));
+                        }
                     }
                     if (extRefs.length > 0) {
                         flow[key] = extRefs;
@@ -993,7 +1006,7 @@ class AttackFlowPublisher implements FilePublisher {
      * @returns
      *  A STIX-formatted JSON property
      */
-    public toStixValue(prop: Property) {
+    public toStixValue(prop: Property): JsonValue {
         if (prop instanceof DateProperty) {
             return prop.toUtcIso();
         } else {

src/attack_flow_builder/src/assets/scripts/OpenChart/DiagramView/DiagramLayoutEngine/AutomaticLayoutEngine/AutomaticLayoutEngine.ts

@@ -22,12 +22,14 @@ export class AutomaticLayoutEngine implements DiagramLayoutEngine {
         const nodes = new Set<DiagramObjectView>();
         const lines = new Set<LineView>();
 
+        // @ts-expect-error: this is a work in progress
         for (const block of objects[0]._blocks) {
             if (block instanceof BlockView) {
                 nodes.add(block);
             }
         }
 
+        // @ts-expect-error: this is a work in progress
         for (const line of objects[0]._lines) {
             if (line instanceof LineView) {
                 lines.add(line);

src/attack_flow_builder/src/assets/scripts/OpenChart/OpenChart.spec.ts

@@ -281,8 +281,8 @@ describe("OpenChart", () => {
         it("exports valid import", async () => {
             const file = await createTestingFile();
             const expected = file.toExport();
-            expected.layout["1dd3ff00-4931-4005-9e7b-b6511e9cd246"] = [5, 5];
-            expected.layout["9aee95bb-6c28-48ad-9ad1-1042ff3e0aaf"] = [7.5, 7.5];
+            expected.layout!["1dd3ff00-4931-4005-9e7b-b6511e9cd246"] = [5, 5];
+            expected.layout!["9aee95bb-6c28-48ad-9ad1-1042ff3e0aaf"] = [7.5, 7.5];
             for (const obj of expected.objects) {
                 if (typeof obj.properties === "undefined") {
                     delete obj.properties;

src/attack_flow_builder/src/assets/scripts/StixToAttackFlow/StixToAttackFlow.ts

@@ -143,7 +143,7 @@ export class StixToAttackFlowConverter {
      */
     private translateStix<T extends DiagramObject>(stix: StixObject, type?: Constructor<T>): T | null {
         // Resolve template
-        const template = StixToTemplate[stix.type];
+        const template = StixToTemplate[stix.type as keyof typeof StixToTemplate];
         if (template === null) {
             return null;
         }

src/attack_flow_builder/src/assets/scripts/StixToAttackFlow/StixTypes/StixObservableObject/StixObservableObject.ts

@@ -12,7 +12,7 @@ import type { Mutex } from "./Mutex";
 import type { NetworkTraffic } from "./NetworkTraffic";
 import type { Process } from "./Process";
 import type { Software } from "./Software";
-import type { Url } from "./URL";
+import type { Url } from "./Url";
 import type { UserAccount } from "./UserAccount";
 import type { WindowsRegistryKey } from "./WindowsRegistryKey";
 import type { X509Certificate } from "./X509Certificate";

src/attack_flow_builder/src/stores/ContextMenuStore.ts

@@ -795,7 +795,7 @@ export const useContextMenuStore = defineStore("contextMenuStore", {
  */
 function prepareCreateMenu(
     templates: ReadonlyMap<string, DiagramObjectTemplate>,
-    spawn: (id: string) => SpawnObject
+    spawn: (id: string) => EditorCommands.GroupCommand
 ): ContextMenuSubmenu<CommandEmitter> {
     type MenuMap<T> = {
         menu: T;