@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

package/src/Obj.test.ts

@@ -4,6 +4,8 @@
 
 import { describe, expectTypeOf, test, expect } from 'vitest';
 
+import { EID } from '@dxos/keys';
+
 import * as Entity from './Entity';
 import { SnapshotKindId } from './internal';
 import * as Obj from './Obj';
@@ -12,6 +14,26 @@ import * as Relation from './Relation';
 import { TestSchema } from './testing';
 
 describe('Obj', () => {
+  describe('make', () => {
+    test('generates a random id when none is provided', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      expect(obj.id).toBeDefined();
+      expect(obj.id.length).toBeGreaterThan(0);
+    });
+
+    test('uses the provided id at creation time', ({ expect }) => {
+      const a = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const b = Obj.make(TestSchema.Person, { name: 'Bob', id: a.id });
+      expect(b.id).toBe(a.id);
+    });
+
+    test('rejects an invalid id format', ({ expect }) => {
+      expect(() => Obj.make(TestSchema.Person, { name: 'Alice', id: 'not-a-ulid' })).toThrow(
+        /Invalid object id format/,
+      );
+    });
+  });
+
   describe('getSnapshot', () => {
     test('getSnapshot returns an immutable snapshot with SnapshotKindId', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
@@ -42,8 +64,8 @@ describe('Obj', () => {
       const snapshot = Obj.getSnapshot(obj);
 
       // getDXN - works with both.
-      expect(Obj.getDXN(obj)).toBeDefined();
-      expect(Obj.getDXN(snapshot)).toBeDefined();
+      expect(Obj.getURI(obj)).toBeDefined();
+      expect(Obj.getURI(snapshot)).toBeDefined();
 
       // getTypename - works with both.
       expect(Obj.getTypename(obj)).toBe('com.example.type.person');
@@ -80,6 +102,86 @@ describe('Obj', () => {
       expect(SnapshotKindId in snapshot).toBe(true);
       expect(Entity.KindId in snapshot).toBe(false);
     });
+
+    test('getSnapshot preserves parent', ({ expect }) => {
+      const parent = Obj.make(TestSchema.Organization, { name: 'parent' });
+      const child = Obj.make(TestSchema.Person, { name: 'child' });
+      Obj.setParent(child, parent);
+
+      const snapshot = Obj.getSnapshot(child);
+
+      expect(Obj.getParent(child)).toBe(parent);
+      expect(Obj.getParent(snapshot)).toBe(parent);
+    });
+  });
+
+  describe('getURI', () => {
+    test('default returns EID', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const uri = Obj.getURI(obj);
+      expect(EID.isEID(uri)).toBe(true);
+    });
+
+    test("prefer: 'relative' returns local EID echo:/<id>", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const uri = Obj.getURI(obj, { prefer: 'relative' });
+      expect(uri).toMatch(/^echo:\/[^/]/);
+      expect(EID.isLocal(EID.parse(uri))).toBe(true);
+    });
+
+    test("prefer: 'relative' works with snapshot", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const snapshot = Obj.getSnapshot(obj);
+      expect(Obj.getURI(snapshot, { prefer: 'relative' })).toBe(Obj.getURI(obj, { prefer: 'relative' }));
+    });
+
+    test("prefer: 'named' returns dxn: URI when meta.key is set", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, {
+        [Obj.Meta]: { key: 'org.dxos.blueprint.webSearch' },
+        name: 'Alice',
+      });
+      const uri = Obj.getURI(obj, { prefer: 'named' });
+      expect(uri).toBe('dxn:org.dxos.blueprint.webSearch');
+    });
+
+    test("prefer: 'named' falls back to EID when meta.key is absent", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const uri = Obj.getURI(obj, { prefer: 'named' });
+      expect(EID.isEID(uri)).toBe(true);
+    });
+
+    test("prefer: 'named' handles key with hyphens (falls back to raw key URI)", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, {
+        [Obj.Meta]: { key: 'org.dxos.blueprint.web-search' },
+        name: 'Alice',
+      });
+      // Hyphens in the final DXN segment are invalid; falls back to the raw key as URI.
+      const uri = Obj.getURI(obj, { prefer: 'named' });
+      expect(uri).toBe('org.dxos.blueprint.web-search');
+    });
+
+    test("prefer: 'absolute' falls back to current EID when object has no database", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      // Without a database the space id is unknown; result is at least a valid EID.
+      const uri = Obj.getURI(obj, { prefer: 'absolute' });
+      expect(EID.isEID(uri)).toBe(true);
+    });
+
+    test("prefer: 'relative' returns the same local EID for reactive and snapshot", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const snapshot = Obj.getSnapshot(obj);
+      expect(Obj.getURI(snapshot, { prefer: 'relative' })).toBe(Obj.getURI(obj, { prefer: 'relative' }));
+    });
+
+    test("prefer: 'named' works the same on snapshot as on reactive (meta.key is preserved)", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, {
+        [Obj.Meta]: { key: 'com.example.foo' },
+        name: 'Alice',
+      });
+      const snapshot = Obj.getSnapshot(obj);
+      expect(Obj.getURI(snapshot, { prefer: 'named' })).toBe(Obj.getURI(obj, { prefer: 'named' }));
+      expect(Obj.getURI(snapshot, { prefer: 'named' })).toBe('dxn:com.example.foo');
+    });
   });
 
   describe('snapshotOf', () => {
@@ -117,7 +219,7 @@ describe('Obj', () => {
 
     test('returns keys from reactive object and snapshot', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
-      Obj.change(obj, (obj) => {
+      Obj.update(obj, (obj) => {
         const meta = Obj.getMeta(obj);
         meta.keys.push({ source: SOURCE, id: 'key-1' });
         meta.keys.push({ source: SOURCE, id: 'key-2' });
@@ -134,7 +236,7 @@ describe('Obj', () => {
 
     test('throws for plain object without metadata', ({ expect }) => {
       const plain = { id: 'plain-1', name: 'Plain' };
-      expect(() => Obj.getKeys(plain as any, SOURCE)).toThrow(/ObjectMeta not found/);
+      expect(() => Obj.getKeys(plain as any, SOURCE)).toThrow(/EntityMeta not found/);
     });
   });
 
@@ -166,7 +268,7 @@ describe('Obj', () => {
 
       const cloned = Obj.clone(original);
 
-      Obj.change(original, (original) => {
+      Obj.update(original, (original) => {
         original.name = 'Bob';
       });
 
@@ -206,7 +308,7 @@ describe('Obj', () => {
       expect(cloned.employer?.target).toBe(person.employer?.target);
 
       // Modifying the referenced object affects both
-      Obj.change(employer, (employer) => {
+      Obj.update(employer, (employer) => {
         employer.name = 'Updated DXOS';
       });
 
@@ -234,7 +336,7 @@ describe('Obj', () => {
       expect(cloned.employer?.target?.name).toBe(employer.name);
 
       // Modifying the original referenced object does not affect the clone
-      Obj.change(employer, (employer) => {
+      Obj.update(employer, (employer) => {
         employer.name = 'Updated DXOS';
       });
 
@@ -329,11 +431,11 @@ describe('Obj', () => {
       expect(cloned.address?.city).toBe('San Francisco');
       expect(cloned.address?.state).toBe('CA');
       expect(cloned.address?.zip).toBe('94102');
-      expect(cloned.address?.coordinates.lat).toBe(37.7749);
-      expect(cloned.address?.coordinates.lng).toBe(-122.4194);
+      expect(cloned.address?.coordinates?.lat).toBe(37.7749);
+      expect(cloned.address?.coordinates?.lng).toBe(-122.4194);
 
       // Modifying nested properties should be independent
-      Obj.change(person, (person) => {
+      Obj.update(person, (person) => {
         person.address!.city = 'New York';
       });
 
@@ -366,7 +468,7 @@ describe('Obj', () => {
       expect(cloned.tasks?.[2]?.target).not.toBe(task3);
 
       // Modifying original tasks should not affect cloned ones
-      Obj.change(task1, (task1) => {
+      Obj.update(task1, (task1) => {
         task1.title = 'Updated Task 1';
       });
 
@@ -405,7 +507,7 @@ describe('Obj', () => {
       const cloned = Obj.clone(person);
 
       expect(Obj.instanceOf(TestSchema.Person, cloned)).toBe(true);
-      expect(Obj.getSchema(cloned)).toBe(Obj.getSchema(person));
+      expect(Obj.getType(cloned)).toBe(Obj.getType(person));
     });
   });
 
@@ -449,7 +551,7 @@ describe('Obj', () => {
     test('returns false when values already match', () => {
       const target = Obj.make(TestSchema.Organization, { name: 'Acme', properties: { region: 'EU' } });
       const source = Obj.make(TestSchema.Organization, { name: 'Acme', properties: { region: 'EU' } });
-      Obj.change(target, (target) => {
+      Obj.update(target, (target) => {
         expect(Obj.updateFrom(target, source)).toBe(false);
       });
     });
@@ -463,7 +565,7 @@ describe('Obj', () => {
         name: 'New',
         properties: { a: '2', b: '3' },
       });
-      Obj.change(target, (target) => {
+      Obj.update(target, (target) => {
         expect(Obj.updateFrom(target, source)).toBe(true);
       });
       expect(target.name).toBe('New');
@@ -487,10 +589,10 @@ describe('Obj', () => {
         employer: Ref.make(orgB),
         address: { city: 'Portland', state: 'OR', zip: '97201', coordinates: { lat: 45.5, lng: -122.6 } },
       });
-      Obj.change(target, (target) => {
+      Obj.update(target, (target) => {
         expect(Obj.updateFrom(target, source)).toBe(true);
       });
-      expect(target.employer?.dxn.toString()).toBe(Ref.make(orgB).dxn.toString());
+      expect(target.employer?.uri.toString()).toBe(Ref.make(orgB).uri.toString());
       expect(target.address?.city).toBe('Portland');
     });
 
@@ -510,16 +612,16 @@ describe('Obj', () => {
         email: 'bob@x.test',
         tasks: [Ref.make(t1), Ref.make(t3)],
       });
-      Obj.change(target, (target) => {
+      Obj.update(target, (target) => {
         expect(Obj.updateFrom(target, source)).toBe(true);
       });
-      expect(target.tasks?.map((r) => r.dxn.toString())).toEqual(source.tasks?.map((r) => r.dxn.toString()));
+      expect(target.tasks?.map((r) => r.uri)).toEqual(source.tasks?.map((r) => r.uri));
     });
 
     test('respects include option', () => {
       const target = Obj.make(TestSchema.Organization, { name: 'Keep', properties: { x: '1' } });
       const source = Obj.make(TestSchema.Organization, { name: 'Drop', properties: { x: '2' } });
-      Obj.change(target, (target) => {
+      Obj.update(target, (target) => {
         expect(Obj.updateFrom(target, source, { include: ['properties'] })).toBe(true);
       });
       expect(target.name).toBe('Keep');
@@ -529,7 +631,7 @@ describe('Obj', () => {
     test('respects exclude option', () => {
       const target = Obj.make(TestSchema.Organization, { name: 'Old', properties: { x: '1' } });
       const source = Obj.make(TestSchema.Organization, { name: 'New', properties: { x: '2' } });
-      Obj.change(target, (target) => {
+      Obj.update(target, (target) => {
         expect(Obj.updateFrom(target, source, { exclude: ['name'] })).toBe(true);
       });
       expect(target.name).toBe('Old');