From 3d04daad287bdb1b421eb468f1bcbd299873bfcc Mon Sep 17 00:00:00 2001
From: Ulad Kasach <uladkasach@gmail.com>
Date: Sun, 7 Dec 2025 22:47:06 -0600
Subject: [PATCH] fix(refs): nested dobjs should be instantiated as refs

---
 src/instantiation/Ref.test.ts         | 3 +--
 src/instantiation/Ref.ts              | 3 +--
 src/instantiation/RefByUnique.test.ts | 3 ++-
 src/instantiation/RefByUnique.ts      | 3 ++-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/instantiation/Ref.test.ts b/src/instantiation/Ref.test.ts
index f23bd81..9dfcdde 100644
--- a/src/instantiation/Ref.test.ts
+++ b/src/instantiation/Ref.test.ts
@@ -3,7 +3,6 @@ import { isRefByUnique } from '../reference/isRefByUnique';
 import { DomainEntity } from './DomainEntity';
 import { DomainLiteral } from './DomainLiteral';
 import { Ref } from './Ref';
-import { RefByUnique } from './RefByUnique';
 
 interface SeaTurtle {
   uuid?: string;
@@ -263,7 +262,7 @@ describe('Ref', () => {
         });
 
         // prove it does not have any non unique key attributes anymore => it was narrowed
-        expect(ref.turtle).toBeInstanceOf(RefByUnique);
+        expect(ref.turtle).toBeInstanceOf(Ref);
         expect(ref.turtle).toHaveProperty('seawaterSecurityNumber', '821');
         expect(ref.turtle).not.toHaveProperty('name');
         expect(ref.turtle).not.toHaveProperty('uuid');
diff --git a/src/instantiation/Ref.ts b/src/instantiation/Ref.ts
index 13f0b51..eadd6b5 100644
--- a/src/instantiation/Ref.ts
+++ b/src/instantiation/Ref.ts
@@ -6,7 +6,6 @@ import { refByUnique } from '../reference/refByUnique';
 import { DomainLiteral } from './DomainLiteral';
 import { isOfDomainEntity } from './inherit/isOfDomainEntity';
 import { isOfDomainEvent } from './inherit/isOfDomainEvent';
-import { RefByUnique } from './RefByUnique';
 
 /**
  * In Domain Driven Design, a Reference is a special type of Domain Literal that represents a reference to another Domain Object.
@@ -52,7 +51,7 @@ class RefBase<T extends DomainObjectShape> extends DomainLiteral<T> {
         typeof value === 'object' &&
         (isOfDomainEntity(value) || isOfDomainEvent(value))
       ) {
-        transformedProps[key] = RefByUnique.as(value);
+        transformedProps[key] = Ref.as(value);
       } else {
         transformedProps[key] = value;
       }
diff --git a/src/instantiation/RefByUnique.test.ts b/src/instantiation/RefByUnique.test.ts
index e75bfa4..0ebc992 100644
--- a/src/instantiation/RefByUnique.test.ts
+++ b/src/instantiation/RefByUnique.test.ts
@@ -1,5 +1,6 @@
 import { DomainEntity } from './DomainEntity';
 import { DomainLiteral } from './DomainLiteral';
+import { Ref } from './Ref';
 import { RefByUnique } from './RefByUnique';
 
 interface SeaTurtle {
@@ -204,7 +205,7 @@ describe('DomainRefByUnique', () => {
         });
 
         // prove it does not have any non unique key attributes anymore => it was narrowed
-        expect(ref.turtle).toBeInstanceOf(RefByUnique);
+        expect(ref.turtle).toBeInstanceOf(Ref);
         expect(ref.turtle).toHaveProperty('seawaterSecurityNumber', '821');
         expect(ref.turtle).not.toHaveProperty('name');
         expect(ref.turtle).not.toHaveProperty('uuid');
diff --git a/src/instantiation/RefByUnique.ts b/src/instantiation/RefByUnique.ts
index afe7786..b139fb7 100644
--- a/src/instantiation/RefByUnique.ts
+++ b/src/instantiation/RefByUnique.ts
@@ -6,6 +6,7 @@ import { refByUnique } from '../reference/refByUnique';
 import { DomainLiteral } from './DomainLiteral';
 import { isOfDomainEntity } from './inherit/isOfDomainEntity';
 import { isOfDomainEvent } from './inherit/isOfDomainEvent';
+import { Ref } from './Ref';
 
 /**
  * In Domain Driven Design, a Reference is a special type of Domain Literal that represents a reference to another Domain Object.
@@ -50,7 +51,7 @@ class RefByUniqueBase<T extends DomainObjectShape> extends DomainLiteral<T> {
         typeof value === 'object' &&
         (isOfDomainEntity(value) || isOfDomainEvent(value))
       ) {
-        transformedProps[key] = RefByUnique.as(value); // todo: is it safe to assume its always unique keys nested within unique keys? find examples where its not?
+        transformedProps[key] = Ref.as(value);
       } else {
         transformedProps[key] = value;
       }