Consider the following:

1. Create a template (Template A), with node type Type A. It has an ID of 123
2. Create a child template Template A Child
3. Create a network, with node Node A using Type A. Type A is defined on the Template A
4. In Template B, create a subclass of Type A -- This has an ID of 789

This results in:

• Type A has ID of 123
• Type A Child has id of 789
• Node A' refers to 123`
• Network A refers to Template B

When requesting Template B, there is no node type with 123, thus resulting in a mismatch between the network and template.

Current Outcome
We now have a network, which is defined as using 'Template B`, but with one of its nodes referring to the Superclass of a node defined withing it, rather than the subclass.

Desired Outcome
Node A in Network A references the child type, either with a HARD reference, or with a SOFT reference -- meaning:

• When creating a subclass of a node in a child template, we update all references to the parent node type in networks which reference the child template
• When requesting a child template, we keep a record of all parent node types (there can be more than one), and leave it to the application to figure out what to do:
  For example, the node_type in template B when returned would look like

{
"id": 789,
"name": "Type A",
"parent_ids": [123]
...
}