Ensure types.maybe(types.reference()) types are resolved late after construction

This fixes a bug in the fast instantiator code where valid references would throw a `can't resolve reference` error due to the instantiation order within MQT. We were accidentally eagerly resolving some references when constructing a tree, instead of late resolving them at the end like we normally do. This only happened for wrapped reference types like a `maybe(reference())` or a `late(reference())` because of an instanceof check instead of a deeper `isReferenceType` check.

Fixes #78, which was an overly broad bug report as it turns out -- class models and normal models correctly late resolve references, regardless of property definition order before this change, it's just when you wrap the reference in a maybe that things got wonky.

Woop woop!

Author: airhorns

spec/class-model-references.spec.ts

@@ -1,6 +1,9 @@
+import { read } from "fs";
 import type { IAnyClassModelType, InstanceWithoutSTNTypeForType, IReferenceType, StateTreeNode } from "../src";
 import { Instance, types } from "../src";
 import { action, ClassModel, register } from "../src/class-model";
+import { Apple } from "./fixtures/FruitAisle";
+import { NameExample } from "./fixtures/NameExample";
 import { create } from "./helpers";
 
 @register
@@ -37,132 +40,175 @@ class Root extends ClassModel({
   refs: types.array(Referrable),
 }) {}
 
-describe("clas model references", () => {
-  test("can resolve valid references", () => {
-    const root = create(
-      Root,
-      {
-        model: {
-          ref: "item-a",
+describe("class model references", () => {
+  describe.each([
+    ["read-only", true],
+    ["observable", false],
+  ])("%s", (_name, readOnly) => {
+    test("can resolve valid references", () => {
+      const root = create(
+        Root,
+        {
+          model: {
+            ref: "item-a",
+          },
+          refs: [
+            { key: "item-a", count: 12 },
+            { key: "item-b", count: 523 },
+          ],
         },
-        refs: [
-          { key: "item-a", count: 12 },
-          { key: "item-b", count: 523 },
-        ],
-      },
-      true,
-    );
+        readOnly,
+      );
 
-    expect(root.model.ref).toEqual(
-      expect.objectContaining({
-        key: "item-a",
-        count: 12,
-      }),
-    );
-  });
+      expect(root.model.ref).toEqual(
+        expect.objectContaining({
+          key: "item-a",
+          count: 12,
+        }),
+      );
+    });
+
+    test("throws for invalid refs", () => {
+      const createRoot = () => {
+        const instance = create(
+          Root,
+          {
+            model: {
+              ref: "item-c",
+            },
+            refs: [
+              { key: "item-a", count: 12 },
+              { key: "item-b", count: 523 },
+            ],
+          },
+          readOnly,
+        );
+        instance.model.ref;
+      };
 
-  test("throws for invalid refs", () => {
-    const createRoot = () =>
-      create(
+      expect(createRoot).toThrow();
+    });
+
+    test("can resolve valid safe references", () => {
+      const root = create(
         Root,
         {
           model: {
-            ref: "item-c",
+            ref: "item-a",
+            safeRef: "item-b",
           },
           refs: [
             { key: "item-a", count: 12 },
             { key: "item-b", count: 523 },
           ],
         },
-        true,
+        readOnly,
       );
 
-    expect(createRoot).toThrow();
-  });
+      expect(root.model.safeRef).toEqual(
+        expect.objectContaining({
+          key: "item-b",
+          count: 523,
+        }),
+      );
+    });
 
-  test("can resolve valid safe references", () => {
-    const root = create(
-      Root,
-      {
-        model: {
-          ref: "item-a",
-          safeRef: "item-b",
+    test("does not throw for invalid safe references", () => {
+      const root = create(
+        Root,
+        {
+          model: {
+            ref: "item-a",
+            safeRef: "item-c",
+          },
+          refs: [
+            { key: "item-a", count: 12 },
+            { key: "item-b", count: 523 },
+          ],
         },
-        refs: [
-          { key: "item-a", count: 12 },
-          { key: "item-b", count: 523 },
-        ],
-      },
-      true,
-    );
+        readOnly,
+      );
 
-    expect(root.model.safeRef).toEqual(
-      expect.objectContaining({
-        key: "item-b",
-        count: 523,
-      }),
-    );
-  });
+      expect(root.model.safeRef).toBeUndefined();
+    });
 
-  test("does not throw for invalid safe references", () => {
-    const root = create(
-      Root,
-      {
-        model: {
-          ref: "item-a",
-          safeRef: "item-c",
+    test("references are equal to the instances they refer to", () => {
+      const root = create(
+        Root,
+        {
+          model: {
+            ref: "item-a",
+            safeRef: "item-b",
+          },
+          refs: [
+            { key: "item-a", count: 12 },
+            { key: "item-b", count: 523 },
+          ],
         },
-        refs: [
-          { key: "item-a", count: 12 },
-          { key: "item-b", count: 523 },
-        ],
-      },
-      true,
-    );
+        readOnly,
+      );
 
-    expect(root.model.safeRef).toBeUndefined();
-  });
+      expect(root.model.ref).toBe(root.refs[0]);
+      expect(root.model.ref).toEqual(root.refs[0]);
+      expect(root.model.ref).toStrictEqual(root.refs[0]);
+    });
 
-  test("references are equal to the instances they refer to", () => {
-    const root = create(
-      Root,
-      {
-        model: {
-          ref: "item-a",
-          safeRef: "item-b",
+    test("safe references are equal to the instances they refer to", () => {
+      const root = create(
+        Root,
+        {
+          model: {
+            ref: "item-a",
+            safeRef: "item-b",
+          },
+          refs: [
+            { key: "item-a", count: 12 },
+            { key: "item-b", count: 523 },
+          ],
         },
-        refs: [
-          { key: "item-a", count: 12 },
-          { key: "item-b", count: 523 },
-        ],
-      },
-      true,
-    );
+        readOnly,
+      );
 
-    expect(root.model.ref).toBe(root.refs[0]);
-    expect(root.model.ref).toEqual(root.refs[0]);
-    expect(root.model.ref).toStrictEqual(root.refs[0]);
-  });
+      expect(root.model.safeRef).toBe(root.refs[1]);
+      expect(root.model.safeRef).toEqual(root.refs[1]);
+      expect(root.model.safeRef).toStrictEqual(root.refs[1]);
+    });
 
-  test("safe references are equal to the instances they refer to", () => {
-    const root = create(
-      Root,
-      {
-        model: {
-          ref: "item-a",
-          safeRef: "item-b",
+    @register
+    class Weird extends ClassModel({
+      examples: types.map(NameExample),
+      obj: types.union(types.reference(NameExample), Apple),
+    }) {}
+
+    test("unions where one type is a reference can be resolved as references", () => {
+      const instance = create(
+        Weird,
+        {
+          examples: {
+            foo: { key: "foo", name: "foo" },
+          },
+          obj: "foo",
         },
-        refs: [
-          { key: "item-a", count: 12 },
-          { key: "item-b", count: 523 },
-        ],
-      },
-      true,
-    );
+        readOnly,
+      );
+
+      expect((instance.obj as NameExample).name).toEqual("foo");
+    });
+
+    test("unions where one type is a reference can be resolved a the non-reference type", () => {
+      const instance = create(
+        Weird,
+        {
+          examples: {
+            foo: { key: "foo", name: "foo" },
+          },
+          obj: { type: "Apple", ripeness: 1 },
+        },
+        readOnly,
+      );
 
-    expect(root.model.safeRef).toBe(root.refs[1]);
-    expect(root.model.safeRef).toEqual(root.refs[1]);
-    expect(root.model.safeRef).toStrictEqual(root.refs[1]);
+      expect((instance.obj as Apple).ripeness).toEqual(1);
+    });
   });
 });