@dxos/echo-atom 0.8.4-main.3eb6e50203 → 0.8.4-main.3fbcb4aa9b

package/src/reactivity.test.ts

@@ -6,8 +6,9 @@ import * as Registry from '@effect-atom/atom/Registry';
 import { describe, expect, test } from 'vitest';
 
 import { Obj } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
 import { createObject } from '@dxos/echo-db';
+import { TestSchema } from '@dxos/echo/testing';
+import { arrayMove } from '@dxos/util';
 
 import * as AtomObj from './atom';
 
@@ -27,9 +28,9 @@ describe('Echo Atom - Reactivity', () => {
     // Subscribe to enable reactivity.
     registry.subscribe(atom, () => {});
 
-    // Update the object via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update the object via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     const updatedSnapshot = registry.get(atom);
@@ -49,9 +50,9 @@ describe('Echo Atom - Reactivity', () => {
     // Subscribe to enable reactivity.
     registry.subscribe(atom, () => {});
 
-    // Update the property via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update the property via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     expect(registry.get(atom)).toBe('Updated');
@@ -81,9 +82,9 @@ describe('Echo Atom - Reactivity', () => {
       emailUpdateCount++;
     });
 
-    // Update only email property via Obj.change.
-    Obj.change(obj, (o) => {
-      o.email = 'updated@example.com';
+    // Update only email property via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.email = 'updated@example.com';
     });
 
     // Name atom should NOT have changed.
@@ -108,10 +109,10 @@ describe('Echo Atom - Reactivity', () => {
     registry.subscribe(nameAtom, () => {});
     registry.subscribe(emailAtom, () => {});
 
-    // Update multiple properties via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
-      o.email = 'updated@example.com';
+    // Update multiple properties via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
+      obj.email = 'updated@example.com';
     });
 
     expect(registry.get(nameAtom)).toBe('Updated');
@@ -139,15 +140,15 @@ describe('Echo Atom - Reactivity', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1);
 
-    // Update object via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update object via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
-    Obj.change(obj, (o) => {
-      o.email = 'updated@example.com';
+    Obj.update(obj, (obj) => {
+      obj.email = 'updated@example.com';
     });
 
-    // Updates fire through Obj.subscribe (one per Obj.change call).
+    // Updates fire through Obj.subscribe (one per Obj.update call).
     expect(updateCount).toBe(initialCount + 2);
 
     // Verify final state - returns snapshot (plain object).
@@ -166,8 +167,8 @@ describe('Echo Atom - Reactivity', () => {
     });
 
     actions.push('before');
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
     actions.push('after');
 
@@ -190,8 +191,8 @@ describe('Echo Atom - Reactivity', () => {
     });
 
     actions.push('before');
-    Obj.change(obj, (o) => {
-      o.stringArray!.splice(1, 1);
+    Obj.update(obj, (obj) => {
+      obj.stringArray!.splice(1, 1);
     });
     actions.push('after');
 
@@ -203,4 +204,30 @@ describe('Echo Atom - Reactivity', () => {
 
     unsubscribe();
   });
+
+  test('property atom for array property updates when array is reordered in place', () => {
+    // Verifies that makeProperty(obj, 'columns')-style atoms subscribe to in-place
+    // array mutations (e.g. arrayMove), so UI stays in sync after column reorder.
+    const obj = createObject(Obj.make(TestSchema.Example, { stringArray: ['a', 'b', 'c'] }));
+
+    const registry = Registry.make();
+    const atom = AtomObj.makeProperty(obj, 'stringArray');
+
+    const initial = registry.get(atom);
+    expect(initial).toEqual(['a', 'b', 'c']);
+
+    let updateCount = 0;
+    registry.subscribe(atom, () => {
+      updateCount++;
+    });
+
+    // Reorder in place (e.g. move first to last).
+    Obj.update(obj, (obj) => {
+      arrayMove(obj.stringArray!, 0, 2);
+    });
+
+    expect(updateCount).toBe(1);
+    const afterReorder = registry.get(atom);
+    expect(afterReorder).toEqual(['b', 'c', 'a']);
+  });
 });

package/src/ref-atom.test.ts

@@ -5,11 +5,13 @@
 import * as Registry from '@effect-atom/atom/Registry';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Obj, Ref } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
+import { Filter, Obj, Ref } from '@dxos/echo';
 import { type EchoDatabase } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { TestSchema } from '@dxos/echo/testing';
+import { PublicKey } from '@dxos/keys';
 
+import * as AtomObj from './atom';
 import * as AtomRef from './ref-atom';
 
 describe('AtomRef - Basic Functionality', () => {
@@ -33,7 +35,7 @@ describe('AtomRef - Basic Functionality', () => {
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const ref = Ref.make(targetObj);
     const atom = AtomRef.make(ref);
@@ -48,7 +50,7 @@ describe('AtomRef - Basic Functionality', () => {
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const ref = Ref.make(targetObj);
     const atom = AtomRef.make(ref);
@@ -60,13 +62,45 @@ describe('AtomRef - Basic Functionality', () => {
     expect(updateCount).toBe(1);
 
     // Mutate target - ref atom does NOT react to this.
-    Obj.change(targetObj, (o) => {
-      o.name = 'Updated';
+    Obj.update(targetObj, (targetObj) => {
+      targetObj.name = 'Updated';
     });
 
     // Update count should still be 1 - ref atom doesn't subscribe to target changes.
     expect(updateCount).toBe(1);
   });
+
+  // Sibling client (sharing services) creates a brand-new ref target. The atom
+  // must update once the target's document propagates and resolves.
+  test('atom resolves target created by sibling client', async () => {
+    const [spaceKey] = PublicKey.randomSequence();
+    await using peer = await testBuilder.createPeer({
+      types: [TestSchema.Person, TestSchema.Container],
+    });
+    await using db1 = await peer.createDatabase(spaceKey);
+    const parent1 = db1.add(Obj.make(TestSchema.Container, { objects: [] }));
+    await db1.flush();
+
+    await using client2 = await peer.createClient();
+    await using db2 = await peer.openDatabase(spaceKey, db1.rootUrl!, { client: client2 });
+    const [parent2] = await db2.query(Filter.id(parent1.id)).run();
+
+    const newPerson = db2.add(
+      Obj.make(TestSchema.Person, { name: 'Alice', username: 'alice', email: 'alice@example.com' }),
+    );
+    Obj.update(parent2, (parent2) => {
+      parent2.objects = [...(parent2.objects ?? []), Ref.make(newPerson)];
+    });
+    await db2.flush();
+
+    await expect.poll(() => (parent1.objects ?? []).length).toBeGreaterThan(0);
+    const atom = AtomObj.make(parent1.objects![0]);
+
+    let lastValue: any;
+    registry.subscribe(atom, (value) => (lastValue = value), { immediate: true });
+
+    await expect.poll(() => lastValue?.name).toBe('Alice');
+  });
 });
 
 describe('AtomRef - Referential Equality', () => {
@@ -90,7 +124,7 @@ describe('AtomRef - Referential Equality', () => {
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const ref = Ref.make(targetObj);
 
@@ -116,7 +150,7 @@ describe('AtomRef - Referential Equality', () => {
     });
     db.add(targetObj1);
     db.add(targetObj2);
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const ref1 = Ref.make(targetObj1);
     const ref2 = Ref.make(targetObj2);
@@ -133,7 +167,7 @@ describe('AtomRef - Referential Equality', () => {
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
-    await db.flush({ indexes: true });
+    await db.flush();
 
     // Create two separate refs to the same target.
     const ref1 = Ref.make(targetObj);
@@ -158,7 +192,7 @@ describe('AtomRef - Referential Equality', () => {
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const ref = Ref.make(targetObj);
 
@@ -197,7 +231,7 @@ describe('AtomRef - Expando Objects', () => {
   test('works with Expando objects', async () => {
     const targetObj = Obj.make(TestSchema.Expando, { name: 'Expando Target', value: 42 });
     db.add(targetObj);
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const ref = Ref.make(targetObj);
     const atom = AtomRef.make(ref);

package/src/ref-utils.ts

@@ -21,19 +21,34 @@ export const loadRefTarget = <T, R>(
   get: Atom.Context,
   onTargetAvailable: (target: T) => R,
 ): R | undefined => {
+  // Accessing `ref.target` registers a resolution callback when the target is
+  // not yet loaded, so resolution can be observed via `ref.onResolved` below.
   const currentTarget = ref.target;
   if (currentTarget) {
     return onTargetAvailable(currentTarget);
   }
 
-  // Target not loaded yet - trigger async load.
+  // Subscribe to the ref's resolution event in case the target loads later
+  // (e.g. when a sibling client creates the linked object). Without this,
+  // a one-shot async load that fails because the document hasn't propagated
+  // would leave the atom permanently undefined.
+  const unsubscribe = ref.onResolved(() => {
+    const target = ref.target;
+    if (target) {
+      get.setSelf(onTargetAvailable(target));
+    }
+  });
+  get.addFinalizer(unsubscribe);
+
+  // Also try async load (e.g. for objects that need disk loading).
   void ref
     .load()
     .then((loadedTarget) => {
       get.setSelf(onTargetAvailable(loadedTarget));
     })
     .catch(() => {
-      // Loading failed, keep target as undefined.
+      // Loading failed; the resolution subscription above will pick up
+      // cross-client updates when they arrive.
     });
 
   return undefined;