dal-engine-core-js-lib-dev 0.0.0 → 0.0.1

package/dist/index.cjs

@@ -54,6 +54,18 @@ ENGINE_TYPES = Object.freeze(ENGINE_TYPES);
 
 var ENGINE_TYPES$1 = ENGINE_TYPES;
 
+class MissingAttributes extends DALEngineError {
+    constructor (type, attribute) {
+        let msg;
+        if (Array.isArray(attribute) && attribute.length > 1) {
+            msg = `"${type}" must be initialized with the attributes "${attribute}".`;
+        } else {
+            msg = `"${type}" must be initialized with the attribute "${attribute}".`;
+        }
+        super(msg);
+    }
+}
+
 /**
  * Class representing a Invariant in the design.
  */
@@ -67,14 +79,32 @@ class Invariant extends Base {
         super();
         this.type = ENGINE_TYPES$1.INVARIANT;
         this.invariantViolated = false;
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadInvariantFromJSON(args);
-            } else {
-                this.name = args.name;
-                this.rule = args.rule;
-            }
+        this.invariantType = null;
+        this.traceId = null;
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadInvariantFromJSON(args);
+        } else {
+            this.loadArgs(args);
+        }
+    }
+
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name", "rule"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Invariant", expectedAttributes);
         }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Invariant", attr);
+            }
+            this[attr] = args[attr];
+        });
     }
 
     /**
@@ -109,13 +139,52 @@ class Invariant extends Base {
     enforceMinLength (value) {
         if ("keys" in this.rule) {
             for (let i = 0; i < this.rule["keys"].length; i++) {
-                console.log(this.rule["keys"][i], value);
                 value = value[this.rule["keys"][i]];
             }
         }        if (value === null || typeof value !== "string" || value.length < this.rule.value) {
             this.invariantViolated = true;
         }
     }
+
+
+    /**
+     * Sets the invariant type.
+     *
+     * The two types of invariants are: Intrinsic and Substrate
+     *
+     * Substrate invariants are learnt by the design from the
+     * environment.
+     *
+     * Intrinsic invariants are arrived at naturally from the
+     * designs control flow, data dependencies and semantic assumptions.
+     *
+     * @param {String} invariantType
+     */
+    setInvariantType (invariantType) {
+        // TODO: Add validation for invariantType.
+        this.invariantType = invariantType;
+    }
+
+    /**
+     * This function adds the trace id which can be used for
+     * automated testing.
+     *
+     * Substrate invariants correspond to a trace that represents
+     * an environment that reveals a limitation of the substrate,
+     * thus motivating the invariant. It is also the environment
+     * in which an implementation can prove that it respects this
+     * invariant.
+     *
+     * Intrisinc invariants correspond to a trace that represents
+     * a factory default environment that enables the implementation
+     * to prove that it respects the invariant.
+     *
+     * @param {String} traceId ID of trace used for automated testing.
+     */
+    setTraceId (traceId) {
+        // TODO: Add validation for traceId.
+        this.traceId = traceId;
+    }
 }
 
 /**
@@ -131,14 +200,32 @@ class Participant extends Base {
         super();
         this.type = ENGINE_TYPES$1.INVARIANT;
         this.invariants = [];
+        this.abstractionId = null;
         this.invariantViolated = false;
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadParticipantFromJSON(args);
-            } else {
-                this.name = args.name;
-            }
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadParticipantFromJSON(args);
+        } else {
+            this.loadArgs(args);
+        }
+    }
+
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Participant", expectedAttributes);
         }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Participant", attr);
+            }
+            this[attr] = args[attr];
+        });
     }
 
     /**
@@ -187,6 +274,18 @@ class Participant extends Base {
         }
         return this.invariantViolated;
     }
+
+    /**
+     * Map the abstraction ID from the execution to the participant.
+     *
+     * This abstraction id will be used to assign a value to the
+     * participant from the execution using the logged abstraction id.
+     *
+     * @param {String} abstractionId
+     */
+    mapAbstraction (abstractionId) {
+        this.abstractionId = abstractionId;
+    }
 }
 
 /**
@@ -202,14 +301,32 @@ class Behavior extends Base {
         super();
         this.type = ENGINE_TYPES$1.BEHAVIOR;
         this.participants = [];
+        this.abstractionIds = [];
         this.invalidWorldState = false;
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadBehaviorFromJSON(args);
-            } else {
-                this.name = args.name;
-            }
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadBehaviorFromJSON(args);
+        } else {
+            this.loadArgs(args);
+        }
+    }
+
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Behavior", expectedAttributes);
         }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Behavior", attr);
+            }
+            this[attr] = args[attr];
+        });
     }
 
     /**
@@ -241,17 +358,21 @@ class Behavior extends Base {
      * @param {*} value
      */
     setParticipantValue (participantName, value) {
-        for (let i = 0; i < this.participants.length; i++) {
-            const participant = this.participants[i];
-            if (participant.name === participantName) {
-                participant.value = value;
-                const violation = participant.enforceInvariants();
-                if (violation) {
-                    this.invalidWorldState = true;
-                }
-            }
+        const participant = this.participants.find(obj => obj.name === participantName);
+        participant.value = value;
+        const violation = participant.enforceInvariants();
+        if (violation) {
+            this.invalidWorldState = true;
         }
     }
+
+    /**
+     * Maps the abstraction id from execution to the behavior.
+     * @param {String} abstractionId
+     */
+    addMapping (abstractionId) {
+        this.abstractionIds.push(abstractionId);
+    }
 }
 
 /**
@@ -412,6 +533,20 @@ class BehavioralControlGraph extends Base {
             throw new InvalidTransitionError(this.currentNode.behavior.name, nextBehaviorName);
         }
     }
+
+    /**
+     * Exports the graph represented using mermaid syntax for visualization.
+     * @returns {String} Graph as mermaid diagram.
+     */
+    exportAsMermaid () {
+        let mermaid = "flowchart TD\n";
+        this.nodes.forEach((node) => {
+            node.goToBehaviors.forEach((behavior) => {
+                mermaid += `  ${node.behavior.name} --> ${behavior.name}\n`;
+            });
+        });
+        return mermaid;
+    }
 }
 
 /**
@@ -419,9 +554,13 @@ class BehavioralControlGraph extends Base {
  * abstraction language. It exposes functions
  * configure the engine through the DAL specification.
  *
- * The execution of an program instrumented with the
- * same design be used to step through the design
- * while the engine automatically debugs the execution.
+ * The design specified in this engine is mapped onto
+ * the implementation using abstraction ids. The
+ * implementation is then instrumented and the resulting
+ * execution trace is fed back into the engine and is
+ * automatically debugged by transforming the execution
+ * into the behavior of the design and enforcing the
+ * invariants.
  */
 class DALEngine {
     constructor (args) {
@@ -454,9 +593,6 @@ class DALEngine {
      * @returns {Participant}
      */
     createParticipant (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
-        // Perhaps it is better to do that in the class itself.
         return new Participant(args);
     }
 
@@ -466,8 +602,6 @@ class DALEngine {
      * @returns {Behavior}
      */
     createBehavior (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
         return new Behavior(args);
     }
 
@@ -477,8 +611,6 @@ class DALEngine {
      * @returns {Invariant}
      */
     createInvariant (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
         return new Invariant(args);
     }
 }

package/dist/index.esm.js

@@ -52,6 +52,18 @@ ENGINE_TYPES$1 = Object.freeze(ENGINE_TYPES$1);
 
 var ENGINE_TYPES = ENGINE_TYPES$1;
 
+class MissingAttributes extends DALEngineError {
+    constructor (type, attribute) {
+        let msg;
+        if (Array.isArray(attribute) && attribute.length > 1) {
+            msg = `"${type}" must be initialized with the attributes "${attribute}".`;
+        } else {
+            msg = `"${type}" must be initialized with the attribute "${attribute}".`;
+        }
+        super(msg);
+    }
+}
+
 /**
  * Class representing a Invariant in the design.
  */
@@ -65,14 +77,32 @@ class Invariant extends Base {
         super();
         this.type = ENGINE_TYPES.INVARIANT;
         this.invariantViolated = false;
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadInvariantFromJSON(args);
-            } else {
-                this.name = args.name;
-                this.rule = args.rule;
-            }
+        this.invariantType = null;
+        this.traceId = null;
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadInvariantFromJSON(args);
+        } else {
+            this.loadArgs(args);
+        }
+    }
+
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name", "rule"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Invariant", expectedAttributes);
         }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Invariant", attr);
+            }
+            this[attr] = args[attr];
+        });
     }
 
     /**
@@ -107,13 +137,52 @@ class Invariant extends Base {
     enforceMinLength (value) {
         if ("keys" in this.rule) {
             for (let i = 0; i < this.rule["keys"].length; i++) {
-                console.log(this.rule["keys"][i], value);
                 value = value[this.rule["keys"][i]];
             }
         }        if (value === null || typeof value !== "string" || value.length < this.rule.value) {
             this.invariantViolated = true;
         }
     }
+
+
+    /**
+     * Sets the invariant type.
+     *
+     * The two types of invariants are: Intrinsic and Substrate
+     *
+     * Substrate invariants are learnt by the design from the
+     * environment.
+     *
+     * Intrinsic invariants are arrived at naturally from the
+     * designs control flow, data dependencies and semantic assumptions.
+     *
+     * @param {String} invariantType
+     */
+    setInvariantType (invariantType) {
+        // TODO: Add validation for invariantType.
+        this.invariantType = invariantType;
+    }
+
+    /**
+     * This function adds the trace id which can be used for
+     * automated testing.
+     *
+     * Substrate invariants correspond to a trace that represents
+     * an environment that reveals a limitation of the substrate,
+     * thus motivating the invariant. It is also the environment
+     * in which an implementation can prove that it respects this
+     * invariant.
+     *
+     * Intrisinc invariants correspond to a trace that represents
+     * a factory default environment that enables the implementation
+     * to prove that it respects the invariant.
+     *
+     * @param {String} traceId ID of trace used for automated testing.
+     */
+    setTraceId (traceId) {
+        // TODO: Add validation for traceId.
+        this.traceId = traceId;
+    }
 }
 
 /**
@@ -129,14 +198,32 @@ class Participant extends Base {
         super();
         this.type = ENGINE_TYPES.INVARIANT;
         this.invariants = [];
+        this.abstractionId = null;
         this.invariantViolated = false;
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadParticipantFromJSON(args);
-            } else {
-                this.name = args.name;
-            }
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadParticipantFromJSON(args);
+        } else {
+            this.loadArgs(args);
+        }
+    }
+
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Participant", expectedAttributes);
         }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Participant", attr);
+            }
+            this[attr] = args[attr];
+        });
     }
 
     /**
@@ -185,6 +272,18 @@ class Participant extends Base {
         }
         return this.invariantViolated;
     }
+
+    /**
+     * Map the abstraction ID from the execution to the participant.
+     *
+     * This abstraction id will be used to assign a value to the
+     * participant from the execution using the logged abstraction id.
+     *
+     * @param {String} abstractionId
+     */
+    mapAbstraction (abstractionId) {
+        this.abstractionId = abstractionId;
+    }
 }
 
 /**
@@ -200,14 +299,32 @@ class Behavior extends Base {
         super();
         this.type = ENGINE_TYPES.BEHAVIOR;
         this.participants = [];
+        this.abstractionIds = [];
         this.invalidWorldState = false;
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadBehaviorFromJSON(args);
-            } else {
-                this.name = args.name;
-            }
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadBehaviorFromJSON(args);
+        } else {
+            this.loadArgs(args);
+        }
+    }
+
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Behavior", expectedAttributes);
         }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Behavior", attr);
+            }
+            this[attr] = args[attr];
+        });
     }
 
     /**
@@ -239,17 +356,21 @@ class Behavior extends Base {
      * @param {*} value
      */
     setParticipantValue (participantName, value) {
-        for (let i = 0; i < this.participants.length; i++) {
-            const participant = this.participants[i];
-            if (participant.name === participantName) {
-                participant.value = value;
-                const violation = participant.enforceInvariants();
-                if (violation) {
-                    this.invalidWorldState = true;
-                }
-            }
+        const participant = this.participants.find(obj => obj.name === participantName);
+        participant.value = value;
+        const violation = participant.enforceInvariants();
+        if (violation) {
+            this.invalidWorldState = true;
         }
     }
+
+    /**
+     * Maps the abstraction id from execution to the behavior.
+     * @param {String} abstractionId
+     */
+    addMapping (abstractionId) {
+        this.abstractionIds.push(abstractionId);
+    }
 }
 
 /**
@@ -410,6 +531,20 @@ class BehavioralControlGraph extends Base {
             throw new InvalidTransitionError(this.currentNode.behavior.name, nextBehaviorName);
         }
     }
+
+    /**
+     * Exports the graph represented using mermaid syntax for visualization.
+     * @returns {String} Graph as mermaid diagram.
+     */
+    exportAsMermaid () {
+        let mermaid = "flowchart TD\n";
+        this.nodes.forEach((node) => {
+            node.goToBehaviors.forEach((behavior) => {
+                mermaid += `  ${node.behavior.name} --> ${behavior.name}\n`;
+            });
+        });
+        return mermaid;
+    }
 }
 
 /**
@@ -417,9 +552,13 @@ class BehavioralControlGraph extends Base {
  * abstraction language. It exposes functions
  * configure the engine through the DAL specification.
  *
- * The execution of an program instrumented with the
- * same design be used to step through the design
- * while the engine automatically debugs the execution.
+ * The design specified in this engine is mapped onto
+ * the implementation using abstraction ids. The
+ * implementation is then instrumented and the resulting
+ * execution trace is fed back into the engine and is
+ * automatically debugged by transforming the execution
+ * into the behavior of the design and enforcing the
+ * invariants.
  */
 class DALEngine {
     constructor (args) {
@@ -452,9 +591,6 @@ class DALEngine {
      * @returns {Participant}
      */
     createParticipant (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
-        // Perhaps it is better to do that in the class itself.
         return new Participant(args);
     }
 
@@ -464,8 +600,6 @@ class DALEngine {
      * @returns {Behavior}
      */
     createBehavior (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
         return new Behavior(args);
     }
 
@@ -475,8 +609,6 @@ class DALEngine {
      * @returns {Invariant}
      */
     createInvariant (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
         return new Invariant(args);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dal-engine-core-js-lib-dev",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "main": "dist/index.cjs",
   "module": "dist/index.esm.js",
   "type": "module",

package/src/BehavioralControlGraph/BehavioralControlGraph.js

@@ -106,6 +106,20 @@ class BehavioralControlGraph extends Base {
             throw new InvalidTransitionError(this.currentNode.behavior.name, nextBehaviorName);
         }
     }
-}
+
+    /**
+     * Exports the graph represented using mermaid syntax for visualization.
+     * @returns {String} Graph as mermaid diagram.
+     */
+    exportAsMermaid () {
+        let mermaid = "flowchart TD\n";
+        this.nodes.forEach((node) => {
+            node.goToBehaviors.forEach((behavior) => {
+                mermaid += `  ${node.behavior.name} --> ${behavior.name}\n`;
+            });
+        });
+        return mermaid;
+    }
+};
 
 export default BehavioralControlGraph;

package/src/DALEngine.js

@@ -8,9 +8,13 @@ import Participant from "./Members/Participant";
  * abstraction language. It exposes functions
  * configure the engine through the DAL specification.
  *
- * The execution of an program instrumented with the
- * same design be used to step through the design
- * while the engine automatically debugs the execution.
+ * The design specified in this engine is mapped onto
+ * the implementation using abstraction ids. The
+ * implementation is then instrumented and the resulting
+ * execution trace is fed back into the engine and is
+ * automatically debugged by transforming the execution
+ * into the behavior of the design and enforcing the
+ * invariants.
  */
 export class DALEngine {
     constructor (args) {
@@ -43,9 +47,6 @@ export class DALEngine {
      * @returns {Participant}
      */
     createParticipant (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
-        // Perhaps it is better to do that in the class itself.
         return new Participant(args);
     }
 
@@ -55,8 +56,6 @@ export class DALEngine {
      * @returns {Behavior}
      */
     createBehavior (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
         return new Behavior(args);
     }
 
@@ -66,8 +65,6 @@ export class DALEngine {
      * @returns {Invariant}
      */
     createInvariant (args) {
-        // TODO: Validate that the args have the necessary keys
-        // and raise custom error if they are missing.
         return new Invariant(args);
     }
 }

package/src/Errors/MissingAttributes.js

@@ -0,0 +1,15 @@
+import DALEngineError from "./DALEngineError";
+
+class MissingAttributes extends DALEngineError {
+    constructor (type, attribute) {
+        let msg;
+        if (Array.isArray(attribute) && attribute.length > 1) {
+            msg = `"${type}" must be initialized with the attributes "${attribute}".`
+        } else {
+            msg = `"${type}" must be initialized with the attribute "${attribute}".`
+        }
+        super(msg);
+    }
+}
+
+export default MissingAttributes;

package/src/Members/Behavior.js

@@ -1,4 +1,5 @@
 import Base from "../Base";
+import MissingAttributes from "../Errors/MissingAttributes";
 import ENGINE_TYPES from "../TYPES";
 import Participant from "./Participant";
 /**
@@ -14,16 +15,34 @@ class Behavior extends Base {
         super();
         this.type = ENGINE_TYPES.BEHAVIOR;
         this.participants = [];
+        this.abstractionIds = [];
         this.invalidWorldState = false;
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadBehaviorFromJSON(args);
-            } else {
-                this.name = args.name;
-            }
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadBehaviorFromJSON(args);
+        } else {
+            this.loadArgs(args);
         }
     }
 
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Behavior", expectedAttributes);
+        }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Behavior", attr);
+            }
+            this[attr] = args[attr];
+        });
+    }
+
     /**
      * Loads the behavior from a JSON object.
      * @param {Object} behaviorJSON
@@ -54,17 +73,21 @@ class Behavior extends Base {
      * @param {*} value
      */
     setParticipantValue (participantName, value) {
-        for (let i = 0; i < this.participants.length; i++) {
-            const participant = this.participants[i];
-            if (participant.name === participantName) {
-                participant.value = value;
-                const violation = participant.enforceInvariants();
-                if (violation) {
-                    this.invalidWorldState = true;
-                }
-            }
+        const participant = this.participants.find(obj => obj.name === participantName);
+        participant.value = value;
+        const violation = participant.enforceInvariants();
+        if (violation) {
+            this.invalidWorldState = true;
         }
     }
+
+    /**
+     * Maps the abstraction id from execution to the behavior.
+     * @param {String} abstractionId
+     */
+    addMapping (abstractionId) {
+        this.abstractionIds.push(abstractionId);
+    }
 }
 
 export default Behavior;

package/src/Members/Invariant.js

@@ -1,5 +1,7 @@
 import Base from "../Base";
+import MissingAttributes from "../Errors/MissingAttributes";
 import ENGINE_TYPES from "../TYPES";
+
 /**
  * Class representing a Invariant in the design.
  */
@@ -12,17 +14,35 @@ class Invariant extends Base {
     constructor (args) {
         super();
         this.type = ENGINE_TYPES.INVARIANT;
-        this.invariantViolated = false
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadInvariantFromJSON(args);
-            } else {
-                this.name = args.name;
-                this.rule = args.rule;
-            }
+        this.invariantViolated = false;
+        this.invariantType = null;
+        this.traceId = null;
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadInvariantFromJSON(args);
+        } else {
+            this.loadArgs(args);
         }
     }
 
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name", "rule"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Invariant", expectedAttributes);
+        }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Invariant", attr);
+            }
+            this[attr] = args[attr];
+        });
+    }
+
     /**
      * Loads the participant from a JSON object.
      * @param {Object} invariantJSON
@@ -56,7 +76,6 @@ class Invariant extends Base {
     enforceMinLength (value) {
         if ("keys" in this.rule) {
             for (let i = 0; i < this.rule["keys"].length; i++) {
-                console.log(this.rule["keys"][i], value)
                 value = value[this.rule["keys"][i]];
             }
         };
@@ -64,6 +83,46 @@ class Invariant extends Base {
             this.invariantViolated = true;
         }
     }
+
+
+    /**
+     * Sets the invariant type.
+     *
+     * The two types of invariants are: Intrinsic and Substrate
+     *
+     * Substrate invariants are learnt by the design from the
+     * environment.
+     *
+     * Intrinsic invariants are arrived at naturally from the
+     * designs control flow, data dependencies and semantic assumptions.
+     *
+     * @param {String} invariantType
+     */
+    setInvariantType (invariantType) {
+        // TODO: Add validation for invariantType.
+        this.invariantType = invariantType;
+    }
+
+    /**
+     * This function adds the trace id which can be used for
+     * automated testing.
+     *
+     * Substrate invariants correspond to a trace that represents
+     * an environment that reveals a limitation of the substrate,
+     * thus motivating the invariant. It is also the environment
+     * in which an implementation can prove that it respects this
+     * invariant.
+     *
+     * Intrisinc invariants correspond to a trace that represents
+     * a factory default environment that enables the implementation
+     * to prove that it respects the invariant.
+     *
+     * @param {String} traceId ID of trace used for automated testing.
+     */
+    setTraceId (traceId) {
+        // TODO: Add validation for traceId.
+        this.traceId = traceId;
+    }
 }
 
 export default Invariant;

package/src/Members/Participant.js

@@ -1,6 +1,8 @@
 import Base from "../Base";
+import MissingAttributes from "../Errors/MissingAttributes";
 import ENGINE_TYPES from "../TYPES";
 import Invariant from "./Invariant";
+
 /**
  * Class representing a participant in the design.
  */
@@ -14,16 +16,34 @@ class Participant extends Base {
         super();
         this.type = ENGINE_TYPES.INVARIANT;
         this.invariants = [];
+        this.abstractionId = null;
         this.invariantViolated = false;
-        if (typeof args === "object" && args !== null) {
-            if (Object.hasOwn(args, "uid")) {
-                this.loadParticipantFromJSON(args);
-            } else {
-                this.name = args.name;
-            }
+        if (typeof args === "object" && Object.hasOwn(args, "uid")) {
+            this.loadParticipantFromJSON(args);
+        } else {
+            this.loadArgs(args);
         }
     }
 
+    /**
+     * Loads the provided arguments.
+     * @throws {MissingAttributes} Thrown when required attr is not present.
+     * @param {Object} args
+     */
+    loadArgs (args) {
+        const expectedAttributes = ["name"];
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+            // Not an object, so all attributes are missing.
+            throw new MissingAttributes("Participant", expectedAttributes);
+        }
+        expectedAttributes.forEach((attr) => {
+            if (!(attr in args)) {
+                throw new MissingAttributes("Participant", attr);
+            }
+            this[attr] = args[attr];
+        });
+    }
+
     /**
      * Loads the participant from a JSON object.
      * @param {Object} participantJSON
@@ -71,6 +91,18 @@ class Participant extends Base {
         }
         return this.invariantViolated;
     }
+
+    /**
+     * Map the abstraction ID from the execution to the participant.
+     *
+     * This abstraction id will be used to assign a value to the
+     * participant from the execution using the logged abstraction id.
+     *
+     * @param {String} abstractionId
+     */
+    mapAbstraction (abstractionId) {
+        this.abstractionId = abstractionId;
+    }
 }
 
 export default Participant;

package/tests/DALEngine.test.js

@@ -4,6 +4,7 @@ import {describe, expect, it} from "vitest";
 
 import {DALEngine} from "../src/DALEngine.js";
 import InvalidTransitionError from "../src/Errors/InvalidTransitionError.js";
+import MissingAttributes from "../src/Errors/MissingAttributes.js";
 import UnknownBehaviorError from "../src/Errors/UnknownBehaviorError.js";
 import ENGINE_TYPES from "../src/TYPES.js";
 
@@ -13,6 +14,16 @@ describe("DALEngine", () => {
         expect(dalInstance.name).toBe("Library Manager");
     });
 
+    it("throws on missing attributes", () => {
+        const d = new DALEngine({name: "Library Manager"});
+        expect(() => {d.createBehavior()}).toThrow(MissingAttributes);
+        expect(() => {d.createBehavior({})}).toThrow(MissingAttributes);
+        expect(() => {d.createBehavior({"rule": "adsf"})}).toThrow(MissingAttributes);
+        expect(() => {d.createInvariant({"name": "asdf"})}).toThrow(MissingAttributes);
+        expect(() => {d.createParticipant()}).toThrow(MissingAttributes);
+        expect(() => {d.createParticipant({})}).toThrow(MissingAttributes);
+    });
+
     it("adds node to graph", () => {
         const d = new DALEngine({name: "Library Manager"});
         const behavior1 = d.createBehavior({name: "AcceptBookFromUser"});
@@ -45,9 +56,9 @@ describe("DALEngine", () => {
         const behavior1 = d.createBehavior({name: "AcceptBookFromUser"});
         const behavior2 = d.createBehavior({name: "AddBookToBasket"});
         const behavior3 = d.createBehavior({name: "AnotherBehavior"});
-        d.graph.addNode(behavior1, [behavior2, behavior3])
-        d.graph.addNode(behavior2, [])
-        d.graph.addNode(behavior3, [])
+        d.graph.addNode(behavior1, [behavior2, behavior3]);
+        d.graph.addNode(behavior2, []);
+        d.graph.addNode(behavior3, []);
 
         // Misspell behavior name to trigger unknown behavior error
         expect(() => {
@@ -82,7 +93,16 @@ describe("DALEngine", () => {
     it("add invariant to participant", () => {
         const d = new DALEngine({name: "Library Manager"});
         const book = d.createParticipant({name: "book"});
-        const invariant = d.createInvariant({name: "minLength"});
+        const invariant = d.createInvariant(
+            {
+                "name": "MinLengthConstraint",
+                "rule": {
+                    "type": "minLength",
+                    "keys": ["value", "name"],
+                    "value": 1,
+                },
+            }
+        );
 
         book.addInvariant(invariant);
 

package/tests/Invariant.test.js

@@ -3,8 +3,17 @@ import {resolve} from "path"
 import {describe, expect, it} from "vitest";
 
 import {DALEngine} from "../src/DALEngine.js";
+import MissingAttributes from "../src/Errors/MissingAttributes.js";
 
 describe("invariantTests", () => {
+
+    it("invariant throws on missing attributes", () => {
+        let d = new DALEngine({name: "Library Manager"});
+        expect(() => {d.createInvariant({"name": "asdf"})}).toThrow(MissingAttributes);
+        expect(() => {d.createInvariant({})}).toThrow(MissingAttributes);
+        expect(() => {d.createInvariant()}).toThrow(MissingAttributes);
+    });
+
     it("test invariant directly through participants", async () => {
         let d = new DALEngine({name: "Library Manager"});
 

package/tests/SimpleDesign.test.js

@@ -0,0 +1,41 @@
+import {readFile, unlink, writeFile} from "fs/promises"
+import {resolve} from "path"
+import {describe, expect, it} from "vitest";
+
+import {DALEngine} from "../src/DALEngine.js";
+
+describe("SimpleDesignTest", () => {
+
+    it("create simple design", async () => {
+        const d = new DALEngine({name: "Library Manager"});
+        let behavior = d.createBehavior({name: "AcceptChoiceToAddBookToBasket"});
+        const AcceptBookFromUser = d.createBehavior({name: "AcceptBookFromUser"});
+        d.graph.addNode(behavior, [AcceptBookFromUser]);
+        const AddBookToBasket = d.createBehavior({name: "AddBookToBasket"});
+        d.graph.addNode(AcceptBookFromUser, [AddBookToBasket]);
+
+        const AcceptChoiceToAuditLibrary = d.createBehavior({name: "AcceptChoiceToAuditLibrary"});
+        const GenerateAuditReport = d.createBehavior({name: "GenerateAuditReport"});
+        d.graph.addNode(AcceptChoiceToAuditLibrary, [GenerateAuditReport]);
+        const HandAuditToUser = d.createBehavior({name: "HandAuditToUser"});
+        d.graph.addNode(GenerateAuditReport, [HandAuditToUser]);
+
+        const AcceptChoiceToPlaceBooksOnShelf = d.createBehavior(
+            {name: "AcceptChoiceToPlaceBooksOnShelf"}
+        );
+        const GetBookFromBasket = d.createBehavior({name: "GetBookFromBasket"});
+        d.graph.addNode(AcceptChoiceToPlaceBooksOnShelf, [GetBookFromBasket]);
+        const GetFirstLetterOfBookName = d.createBehavior({name: "GetFirstLetterOfBookName"});
+        d.graph.addNode(GetBookFromBasket, [GetFirstLetterOfBookName]);
+        const CreateSlotOnBookShelf = d.createBehavior({name: "CreateSlotOnBookShelf"});
+        const AddBookToShelf = d.createBehavior({name: "AddBookToShelf"});
+        d.graph.addNode(GetFirstLetterOfBookName, [CreateSlotOnBookShelf]);
+        d.graph.addNode(GetFirstLetterOfBookName, [AddBookToShelf]);
+        d.graph.addNode(CreateSlotOnBookShelf, [AddBookToShelf]);
+        d.graph.addNode(AddBookToShelf, [GetBookFromBasket]);
+
+        // Output can be viewed using https://mermaid.live/
+        const filePath2 = resolve(__dirname, "./temp/simple_design_mermaid.txt")
+        await writeFile(filePath2, d.graph.exportAsMermaid())
+    });
+});