I'll start with what is it that I want to achieve. We have a graph DB that stores different types of nodes. Each type of nodes have a certain set of properties. Each property is a string in the DB, but can be an encoding of a more complicated data structure. For example, let's say we have:
PersonNode {
name,
age,
}
DogNode {
breed,
favorite_foods, // JSON-encoded list of strings
}
In our client code, we have a low-level Node class that exposes the properties of a node as a key-value map. We want to build upon this low-level Node to expose a type-safe interface to end users, so they don't have to check for key existence / decode things themselves.
A coworker proposed that we can create a different class for each type of nodes, with different getters for properties. For example (in pseudocode):
class PersonNode {
string get_name() { ... }
int get_age() { ... }
}
class DogNode {
string get_breed() { ... }
list<string> get_favorite_foods() { ... }
}
But my concern with this approach is that if we want to return different types of nodes from the DB, we need to store them in a collection, which means we need to make different node types inherit from a BaseNode. But then the user will need to do runtime type checks for each node before they can use their getters. I feel this defeats the purpose of polymorphism:
list<BaseNode> nodes = get_nodes_from_db()
for node in nodes:
if instanceof(node, PersonNode):
...
elif instanceof(node, DogNode):
...
Is there any pattern we can use that avoids runtime type checks, but can also give us type safety when accessing the properties of each node type?
